From 6990bd5752099d1158ed2c30940ffcaf61e33f56 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 31 Dec 2021 14:48:52 +0900 Subject: [PATCH 001/360] [gamecode] Add some more comments to dfunction_t --- include/QF/pr_comp.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index 0cd65d7e5..9072ea643 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -457,15 +457,15 @@ typedef struct dparmsize_s { typedef struct dfunction_s { pr_int_t first_statement; // negative numbers are builtins - pr_uint_t parm_start; + pr_uint_t parm_start; // beginning of locals data space pr_uint_t locals; // total ints of parms + locals pr_uint_t profile; // runtime - string_t s_name; + string_t s_name; // source function name string_t s_file; // source file defined in - pr_int_t numparms; + pr_int_t numparms; // -ve is varargs (1s comp of real count) dparmsize_t parm_size[MAX_PARMS]; } dfunction_t; From be474d9937ff2a28f141e342fa8b19dd893d9e2c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 31 Dec 2021 15:02:31 +0900 Subject: [PATCH 002/360] [gamecode] Remove the wart from def and function names I never liked the leading s_ (though I guess it means one is supposed to interpret the int as a string pointer, but meh). --- include/QF/pr_comp.h | 6 +++--- libs/gamecode/pr_builtins.c | 8 ++++---- libs/gamecode/pr_debug.c | 26 +++++++++++++------------- libs/gamecode/pr_exec.c | 10 +++++----- libs/gamecode/pr_load.c | 18 +++++++++--------- libs/gamecode/pr_parse.c | 2 +- nq/source/sv_pr_cmds.c | 4 ++-- qw/source/sv_pr_cmds.c | 4 ++-- ruamoko/qwaq/builtins/debug.c | 4 ++-- tools/qfcc/source/def.c | 2 +- tools/qfcc/source/disassemble.c | 2 +- tools/qfcc/source/dump_globals.c | 4 ++-- tools/qfcc/source/dump_lines.c | 4 ++-- tools/qfcc/source/idstuff.c | 6 +++--- tools/qfcc/source/obj_file.c | 6 +++--- tools/qfcc/source/qfcc.c | 8 ++++---- 16 files changed, 57 insertions(+), 57 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index 9072ea643..ff71cd6fc 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -425,7 +425,7 @@ typedef struct ddef_s { pr_ushort_t type; // if DEF_SAVEGLOBAL bit is set // the variable needs to be saved in savegames pr_ushort_t ofs; - string_t s_name; + string_t name; } ddef_t; typedef struct xdef_s { @@ -462,8 +462,8 @@ typedef struct dfunction_s { pr_uint_t profile; // runtime - string_t s_name; // source function name - string_t s_file; // source file defined in + string_t name; // source function name + string_t file; // source file defined in pr_int_t numparms; // -ve is varargs (1s comp of real count) dparmsize_t parm_size[MAX_PARMS]; diff --git a/libs/gamecode/pr_builtins.c b/libs/gamecode/pr_builtins.c index b5332db7f..150b43932 100644 --- a/libs/gamecode/pr_builtins.c +++ b/libs/gamecode/pr_builtins.c @@ -95,7 +95,7 @@ bi_no_function (progs_t *pr) // descriptor with a bad builtin number dstatement_t *st = pr->pr_statements + pr->pr_xstatement; dfunction_t *desc = pr->pr_functions + G_FUNCTION (pr, st->a); - const char *bi_name = PR_GetString (pr, desc->s_name); + const char *bi_name = PR_GetString (pr, desc->name); int ind = -desc->first_statement; PR_RunError (pr, "Bad builtin called: %s = #%d", bi_name, ind); @@ -201,7 +201,7 @@ PR_RelocateBuiltins (progs_t *pr) if (desc->first_statement > 0) continue; - bi_name = PR_GetString (pr, desc->s_name); + bi_name = PR_GetString (pr, desc->name); if (!desc->first_statement) { bi = PR_FindBuiltin (pr, bi_name); @@ -225,8 +225,8 @@ PR_RelocateBuiltins (progs_t *pr) bi_name, -desc->first_statement); proc = bi_no_function; } - if (!desc->s_name && bi) { - desc->s_name = PR_SetString (pr, bi->name); + if (!desc->name && bi) { + desc->name = PR_SetString (pr, bi->name); Hash_Add (pr->function_hash, &pr->pr_functions[i]); } func->first_statement = desc->first_statement; diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index f80913137..f9f743e0d 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -496,8 +496,8 @@ func_compare_sort (const void *_fa, const void *_fb, void *_res) progs_t *pr = res->pr; func_t fa = *(const func_t *)_fa; func_t fb = *(const func_t *)_fb; - const char *fa_file = PR_GetString (pr, pr->pr_functions[fa].s_file); - const char *fb_file = PR_GetString (pr, pr->pr_functions[fb].s_file); + const char *fa_file = PR_GetString (pr, pr->pr_functions[fa].file); + const char *fb_file = PR_GetString (pr, pr->pr_functions[fb].file); int cmp = strcmp (fa_file, fb_file); if (cmp) { return cmp; @@ -516,7 +516,7 @@ func_compare_search (const void *_key, const void *_f, void *_res) progs_t *pr = res->pr; const func_key_t *key = _key; func_t f = *(const func_t *)_f; - const char *f_file = PR_GetString (pr, pr->pr_functions[f].s_file); + const char *f_file = PR_GetString (pr, pr->pr_functions[f].file); int cmp = strcmp (key->file, f_file); if (cmp) { return cmp; @@ -837,7 +837,7 @@ PR_FindSourceLineAddr (progs_t *pr, const char *file, pr_uint_t line) } dfunction_t *func = &pr->pr_functions[*f]; if (func->first_statement <= 0 - || strcmp (file, PR_GetString (pr, func->s_file)) != 0) { + || strcmp (file, PR_GetString (pr, func->file)) != 0) { return 0; } pr_auxfunction_t *aux = res->auxfunction_map[*f]; @@ -869,7 +869,7 @@ PR_Get_Source_File (progs_t *pr, pr_lineno_t *lineno) f = PR_Get_Lineno_Func (pr, lineno); if (f->function >= (unsigned) pr->progs->numfunctions) return 0; - return PR_GetString(pr, pr->pr_functions[f->function].s_file); + return PR_GetString(pr, pr->pr_functions[f->function].file); } const char * @@ -1292,7 +1292,7 @@ pr_debug_func_view (qfot_type_t *type, pr_type_t *value, void *_data) dstring_appendstr (dstr, "NULL"); } else { dfunction_t *f = pr->pr_functions + value->func_var; - dasprintf (dstr, "%s()", PR_GetString (pr, f->s_name)); + dasprintf (dstr, "%s()", PR_GetString (pr, f->name)); } } @@ -1673,20 +1673,20 @@ dump_frame (progs_t *pr, prstack_t *frame) line += func->source_line; if (addr == frame->staddr) { Sys_Printf ("%12s:%u : %s: %x\n", - PR_GetString (pr, f->s_file), + PR_GetString (pr, f->file), line, - PR_GetString (pr, f->s_name), + PR_GetString (pr, f->name), frame->staddr); } else { Sys_Printf ("%12s:%u+%d : %s: %x\n", - PR_GetString (pr, f->s_file), + PR_GetString (pr, f->file), line, frame->staddr - addr, - PR_GetString (pr, f->s_name), + PR_GetString (pr, f->name), frame->staddr); } } else { - Sys_Printf ("%12s : %s: %x\n", PR_GetString (pr, f->s_file), - PR_GetString (pr, f->s_name), frame->staddr); + Sys_Printf ("%12s : %s: %x\n", PR_GetString (pr, f->file), + PR_GetString (pr, f->name), frame->staddr); } } @@ -1730,7 +1730,7 @@ PR_Profile (progs_t * pr) if (num < 10) { f = pr->pr_functions + (best - pr->function_table); Sys_Printf ("%7i %s\n", best->profile, - PR_GetString (pr, f->s_name)); + PR_GetString (pr, f->name)); } num++; best->profile = 0; diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 09d8b9fc8..af7517a92 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -195,7 +195,7 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) if (pr->pr_trace && !pr->debug_handler) { Sys_Printf ("Entering function %s\n", - PR_GetString (pr, f->descriptor->s_name)); + PR_GetString (pr, f->descriptor->name)); } PR_PushFrame (pr); @@ -238,7 +238,7 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) } } - //Sys_Printf("%s:\n", PR_GetString(pr,f->s_name)); + //Sys_Printf("%s:\n", PR_GetString(pr,f->name)); pr->pr_xfunction = f; pr->pr_xstatement = f->first_statement - 1; // offset the st++ @@ -286,14 +286,14 @@ PR_LeaveFunction (progs_t *pr, int to_engine) if (pr->pr_trace && !pr->debug_handler) { Sys_Printf ("Leaving function %s\n", - PR_GetString (pr, f->descriptor->s_name)); + PR_GetString (pr, f->descriptor->name)); if (to_engine) { Sys_Printf ("Returning to engine\n"); } else { bfunction_t *rf = pr->pr_xfunction; if (rf) { Sys_Printf ("Returning to function %s\n", - PR_GetString (pr, rf->descriptor->s_name)); + PR_GetString (pr, rf->descriptor->name)); } } } @@ -407,7 +407,7 @@ PR_CallFunction (progs_t *pr, func_t fnum) // negative statements are built in functions if (pr->pr_trace && !pr->debug_handler) { Sys_Printf ("Calling builtin %s @ %p\n", - PR_GetString (pr, f->descriptor->s_name), f->func); + PR_GetString (pr, f->descriptor->name), f->func); } f->func (pr); return 0; diff --git a/libs/gamecode/pr_load.c b/libs/gamecode/pr_load.c index 55c556aac..40f99dd84 100644 --- a/libs/gamecode/pr_load.c +++ b/libs/gamecode/pr_load.c @@ -58,7 +58,7 @@ function_get_key (const void *f, void *_pr) { progs_t *pr = (progs_t*)_pr; dfunction_t *func = (dfunction_t*)f; - return PR_GetString (pr, func->s_name); + return PR_GetString (pr, func->name); } static const char * @@ -247,12 +247,12 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) LittleLong (pr->pr_functions[i].first_statement); pr->pr_functions[i].parm_start = LittleLong (pr->pr_functions[i].parm_start); - pr->pr_functions[i].s_name = LittleLong (pr->pr_functions[i].s_name); - pr->pr_functions[i].s_file = LittleLong (pr->pr_functions[i].s_file); + pr->pr_functions[i].name = LittleLong (pr->pr_functions[i].name); + pr->pr_functions[i].file = LittleLong (pr->pr_functions[i].file); pr->pr_functions[i].numparms = LittleLong (pr->pr_functions[i].numparms); pr->pr_functions[i].locals = LittleLong (pr->pr_functions[i].locals); - if (pr->pr_functions[i].s_name) + if (pr->pr_functions[i].name) Hash_Add (pr->function_hash, &pr->pr_functions[i]); } @@ -265,12 +265,12 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) pr_ushort_t safe_type = global_ddefs[i].type & ~DEF_SAVEGLOBAL; global_ddefs[i].type = LittleShort (global_ddefs[i].type); global_ddefs[i].ofs = LittleShort (global_ddefs[i].ofs); - global_ddefs[i].s_name = LittleLong (global_ddefs[i].s_name); + global_ddefs[i].name = LittleLong (global_ddefs[i].name); pr->pr_globaldefs[i].type = global_ddefs[i].type; pr->pr_globaldefs[i].size = pr_type_size[safe_type]; pr->pr_globaldefs[i].ofs = global_ddefs[i].ofs; - pr->pr_globaldefs[i].name = global_ddefs[i].s_name; + pr->pr_globaldefs[i].name = global_ddefs[i].name; Hash_Add (pr->global_hash, &pr->pr_globaldefs[i]); } @@ -283,11 +283,11 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) if (field_ddefs[i].type & DEF_SAVEGLOBAL) PR_Error (pr, "PR_LoadProgs: DEF_SAVEGLOBAL on field def %zd", i); field_ddefs[i].ofs = LittleShort (field_ddefs[i].ofs); - field_ddefs[i].s_name = LittleLong (field_ddefs[i].s_name); + field_ddefs[i].name = LittleLong (field_ddefs[i].name); pr->pr_fielddefs[i].type = field_ddefs[i].type; pr->pr_fielddefs[i].ofs = field_ddefs[i].ofs; - pr->pr_fielddefs[i].name = field_ddefs[i].s_name; + pr->pr_fielddefs[i].name = field_ddefs[i].name; Hash_Add (pr->field_hash, &pr->pr_fielddefs[i]); } @@ -365,7 +365,7 @@ pr_run_ctors (progs_t *pr) for (fnum = 0; fnum < pr->progs->numfunctions; fnum++) { func = pr->pr_functions + fnum; - if (strequal (PR_GetString (pr, func->s_name), ".ctor")) + if (strequal (PR_GetString (pr, func->name), ".ctor")) PR_ExecuteProgram (pr, fnum); } return 1; diff --git a/libs/gamecode/pr_parse.c b/libs/gamecode/pr_parse.c index cfc170815..8b4c2d728 100644 --- a/libs/gamecode/pr_parse.c +++ b/libs/gamecode/pr_parse.c @@ -76,7 +76,7 @@ PR_UglyValueString (progs_t *pr, etype_t type, pr_type_t *val, dstring_t *line) break; case ev_func: f = pr->pr_functions + val->func_var; - dsprintf (line, "%s", PR_GetString (pr, f->s_name)); + dsprintf (line, "%s", PR_GetString (pr, f->name)); break; case ev_field: def = PR_FieldAtOfs (pr, val->integer_var); diff --git a/nq/source/sv_pr_cmds.c b/nq/source/sv_pr_cmds.c index 466fa92cb..8f2262078 100644 --- a/nq/source/sv_pr_cmds.c +++ b/nq/source/sv_pr_cmds.c @@ -73,7 +73,7 @@ PF_error (progs_t *pr) s = PF_VarString (pr, 0); Sys_Printf ("======SERVER ERROR in %s:\n%s\n", - PR_GetString (pr, pr->pr_xfunction->descriptor->s_name), s); + PR_GetString (pr, pr->pr_xfunction->descriptor->name), s); ed = PROG_TO_EDICT (pr, *sv_globals.self); ED_Print (pr, ed, 0); @@ -97,7 +97,7 @@ PF_objerror (progs_t *pr) s = PF_VarString (pr, 0); Sys_Printf ("======OBJECT ERROR in %s:\n%s\n", - PR_GetString (pr, pr->pr_xfunction->descriptor->s_name), s); + PR_GetString (pr, pr->pr_xfunction->descriptor->name), s); ed = PROG_TO_EDICT (pr, *sv_globals.self); ED_Print (pr, ed, 0); ED_Free (pr, ed); diff --git a/qw/source/sv_pr_cmds.c b/qw/source/sv_pr_cmds.c index 36498b8bd..2e1144780 100644 --- a/qw/source/sv_pr_cmds.c +++ b/qw/source/sv_pr_cmds.c @@ -75,7 +75,7 @@ PF_error (progs_t *pr) s = PF_VarString (pr, 0); Sys_Printf ("======SERVER ERROR in %s:\n%s\n", - PR_GetString (pr, pr->pr_xfunction->descriptor->s_name), s); + PR_GetString (pr, pr->pr_xfunction->descriptor->name), s); ed = PROG_TO_EDICT (pr, *sv_globals.self); ED_Print (pr, ed, 0); @@ -99,7 +99,7 @@ PF_objerror (progs_t *pr) s = PF_VarString (pr, 0); Sys_Printf ("======OBJECT ERROR in %s:\n%s\n", - PR_GetString (pr, pr->pr_xfunction->descriptor->s_name), s); + PR_GetString (pr, pr->pr_xfunction->descriptor->name), s); ed = PROG_TO_EDICT (pr, *sv_globals.self); ED_Print (pr, ed, 0); ED_Free (pr, ed); diff --git a/ruamoko/qwaq/builtins/debug.c b/ruamoko/qwaq/builtins/debug.c index 4826c4166..56aaa818c 100644 --- a/ruamoko/qwaq/builtins/debug.c +++ b/ruamoko/qwaq/builtins/debug.c @@ -525,8 +525,8 @@ return_function (progs_t *pr, dfunction_t *func) f->local_data = func->parm_start; f->local_size = func->locals; f->profile = func->profile; - f->name = func->s_name; - f->file = func->s_file; + f->name = func->name; + f->file = func->file; f->num_params = func->numparms; R_POINTER (pr) = PR_SetPointer (pr, f); } diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c index df1d36b94..216497a73 100644 --- a/tools/qfcc/source/def.c +++ b/tools/qfcc/source/def.c @@ -284,7 +284,7 @@ def_to_ddef (def_t *def, ddef_t *ddef, int aux) type = type->t.fldptr.type; // aux is true only for fields ddef->type = type->type; ddef->ofs = def->offset; - ddef->s_name = ReuseString (def->name); + ddef->name = ReuseString (def->name); } static int diff --git a/tools/qfcc/source/disassemble.c b/tools/qfcc/source/disassemble.c index 7002510bc..60e4765bc 100644 --- a/tools/qfcc/source/disassemble.c +++ b/tools/qfcc/source/disassemble.c @@ -76,7 +76,7 @@ disassemble_progs (progs_t *pr) memcpy (func.parm_size, desc->parm_size, sizeof (func.parm_size)); func.descriptor = desc; - Sys_Printf ("%s:\n", PR_GetString (pr, desc->s_name)); + Sys_Printf ("%s:\n", PR_GetString (pr, desc->name)); pr->pr_xfunction = &func; } PR_PrintStatement (pr, &pr->pr_statements[i], 2 | (verbosity > 1)); diff --git a/tools/qfcc/source/dump_globals.c b/tools/qfcc/source/dump_globals.c index e01005a47..ff8f6d32f 100644 --- a/tools/qfcc/source/dump_globals.c +++ b/tools/qfcc/source/dump_globals.c @@ -251,7 +251,7 @@ dump_functions (progs_t *pr) for (i = 0; i < pr->progs->numfunctions; i++) { dfunction_t *func = &pr->pr_functions[i]; - name = PR_GetString (pr, func->s_name); + name = PR_GetString (pr, func->name); start = func->first_statement; if (start > 0) @@ -275,7 +275,7 @@ dump_functions (progs_t *pr) continue; } printf (" %d %s:%d %d %d %d %x\n", aux->function, - PR_GetString (pr, func->s_file), aux->source_line, + PR_GetString (pr, func->file), aux->source_line, aux->line_info, aux->local_defs, aux->num_locals, aux->return_type); diff --git a/tools/qfcc/source/dump_lines.c b/tools/qfcc/source/dump_lines.c index 044c7fdc7..bfaffdc6e 100644 --- a/tools/qfcc/source/dump_lines.c +++ b/tools/qfcc/source/dump_lines.c @@ -79,8 +79,8 @@ progs_get_func_data (unsigned func_index, void *data) func_data.function = aux_func->function; if (aux_func->function < (unsigned int) pr->progs->numfunctions) { func = pr->pr_functions + aux_func->function; - func_data.source_file = pr->pr_strings + func->s_file; - func_data.source_name = pr->pr_strings + func->s_name; + func_data.source_file = pr->pr_strings + func->file; + func_data.source_name = pr->pr_strings + func->name; func_data.first_statement = func->first_statement; } return &func_data; diff --git a/tools/qfcc/source/idstuff.c b/tools/qfcc/source/idstuff.c index 1bc222f49..f78658247 100644 --- a/tools/qfcc/source/idstuff.c +++ b/tools/qfcc/source/idstuff.c @@ -215,7 +215,7 @@ WriteProgdefs (dprograms_t *progs, const char *filename) strings = (char *) progs + progs->ofs_strings; for (i = 0; i < progs->numglobaldefs; i++) { def = (ddef_t *) ((char *) progs + progs->ofs_globaldefs) + i; - name = strings + def->s_name; + name = strings + def->name; if (!strcmp (name, "end_sys_globals")) break; if (!def->ofs) @@ -253,7 +253,7 @@ WriteProgdefs (dprograms_t *progs, const char *filename) dasprintf (dstr, "typedef struct\n{\n"); for (i = 0, j = 0; i < progs->numglobaldefs; i++) { def = (ddef_t *) ((char *) progs + progs->ofs_globaldefs) + i; - name = strings + def->s_name; + name = strings + def->name; if (!strcmp (name, "end_sys_fields")) break; @@ -265,7 +265,7 @@ WriteProgdefs (dprograms_t *progs, const char *filename) continue; fdef = (ddef_t *) ((char *) progs + progs->ofs_fielddefs) + j++; - if (fdef->s_name != def->s_name) + if (fdef->name != def->name) internal_error (0, "def and field order messup"); switch (fdef->type) { diff --git a/tools/qfcc/source/obj_file.c b/tools/qfcc/source/obj_file.c index afe295961..22403f7ae 100644 --- a/tools/qfcc/source/obj_file.c +++ b/tools/qfcc/source/obj_file.c @@ -819,7 +819,7 @@ qfo_def_to_ddef (qfo_t *qfo, const qfo_def_t *def, ddef_t *ddef) { ddef->type = get_def_type (qfo, def->type); ddef->ofs = def->offset; - ddef->s_name = def->name; + ddef->name = def->name; if (!(def->flags & QFOD_NOSAVE) && !(def->flags & QFOD_CONSTANT) && (def->flags & QFOD_GLOBAL) @@ -1079,8 +1079,8 @@ qfo_to_progs (qfo_t *in_qfo, int *size) if (!options.code.local_merging) locals_start += align_globals_size (df->locals); df->profile = 0; - df->s_name = qf->name; - df->s_file = qf->file; + df->name = qf->name; + df->file = qf->file; function_params (qfo, qf, df); } diff --git a/tools/qfcc/source/qfcc.c b/tools/qfcc/source/qfcc.c index 1a8406186..2e656a21e 100644 --- a/tools/qfcc/source/qfcc.c +++ b/tools/qfcc/source/qfcc.c @@ -231,19 +231,19 @@ WriteProgs (dprograms_t *progs, int size) func->parm_start = LittleLong (func->parm_start); func->locals = LittleLong (func->locals); func->profile = LittleLong (func->profile); - func->s_name = LittleLong (func->s_name); - func->s_file = LittleLong (func->s_file); + func->name = LittleLong (func->name); + func->file = LittleLong (func->file); func->numparms = LittleLong (func->numparms); } for (i = 0; i < progs->numglobaldefs; i++) { globaldefs[i].type = LittleShort (globaldefs[i].type); globaldefs[i].ofs = LittleShort (globaldefs[i].ofs); - globaldefs[i].s_name = LittleLong (globaldefs[i].s_name); + globaldefs[i].name = LittleLong (globaldefs[i].name); } for (i = 0; i < progs->numfielddefs; i++) { fielddefs[i].type = LittleShort (fielddefs[i].type); fielddefs[i].ofs = LittleShort (fielddefs[i].ofs); - fielddefs[i].s_name = LittleLong (fielddefs[i].s_name); + fielddefs[i].name = LittleLong (fielddefs[i].name); } for (i = 0; i < progs->numglobals; i++) globals[i].integer_var = LittleLong (globals[i].integer_var); From 365762b8a6b7b87e50b1ee17c2e0d2decba40ba3 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 31 Dec 2021 19:16:02 +0900 Subject: [PATCH 003/360] [gamecode] Switch to using indexed initializers The opcode table is a nightmare to maintain, but this does clean it up and speed up opcode lookups since they can now be indexed. Of course, it turns out I had missed adding several instructions, so had to fix that, and qfcc needed a bit of a re-jigger to get the opcode out of the table. --- include/QF/pr_comp.h | 13 +- libs/gamecode/pr_debug.c | 2 +- libs/gamecode/pr_opcode.c | 657 ++++++++++++++++++----------------- tools/qfcc/include/opcodes.h | 2 + tools/qfcc/source/emit.c | 2 +- tools/qfcc/source/opcodes.c | 22 +- 6 files changed, 354 insertions(+), 344 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index ff71cd6fc..5d5efe942 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -403,17 +403,16 @@ typedef enum { #define OP_BREAK 0x8000 typedef struct opcode_s { - const char *name; - const char *opname; - pr_opcode_e opcode; - qboolean right_associative; - etype_t type_a, type_b, type_c; + const char *name; + const char *opname; + qboolean right_associative; + etype_t type_a, type_b, type_c; unsigned int min_version; - const char *fmt; + const char *fmt; } opcode_t; extern const opcode_t pr_opcodes[]; -opcode_t *PR_Opcode (pr_short_t opcode); +const opcode_t *PR_Opcode (pr_short_t opcode) __attribute__((const)); void PR_Opcode_Init (void); // idempotent typedef struct dstatement_s { diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index f9f743e0d..55cca36d0 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -1482,7 +1482,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) int addr = s - pr->pr_statements; int dump_code = contents & 2; const char *fmt; - opcode_t *op; + const opcode_t *op; dfunction_t *call_func = 0; pr_def_t *parm_def = 0; pr_auxfunction_t *aux_func = 0; diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index 2c893b39f..62239c561 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -39,15 +39,12 @@ #endif #include "QF/cvar.h" -#include "QF/hash.h" #include "QF/pr_comp.h" #include "QF/progs.h" #include "QF/sys.h" #include "compat.h" -static hashtab_t *opcode_table; - VISIBLE const pr_ushort_t pr_type_size[ev_type_count] = { 1, // ev_void 1, // ev_string @@ -99,1430 +96,1438 @@ VISIBLE const char * const pr_type_name[ev_type_count] = { // x place holder for P (padding) // 0-7 parameter index (for P) VISIBLE const opcode_t pr_opcodes[] = { - {"", "done", OP_DONE, false, // OP_DONE is actually the same as + [OP_DONE] = {"", "done", false, // OP_DONE is actually the same as ev_entity, ev_field, ev_void, // OP_RETURN, the types are bogus PROG_ID_VERSION, "%Va", }, - {"*", "mul.d", OP_MUL_D, false, + [OP_MUL_D] = {"*", "mul.d", false, ev_double, ev_double, ev_double, PROG_VERSION, }, - {"*", "mul.f", OP_MUL_F, false, + [OP_MUL_F] = {"*", "mul.f", false, ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - {"*", "mul.v", OP_MUL_V, false, + [OP_MUL_V] = {"*", "mul.v", false, ev_vector, ev_vector, ev_float, PROG_ID_VERSION, }, - {"*", "mul.fv", OP_MUL_FV, false, + [OP_MUL_FV] = {"*", "mul.fv", false, ev_float, ev_vector, ev_vector, PROG_ID_VERSION, }, - {"*", "mul.vf", OP_MUL_VF, false, + [OP_MUL_VF] = {"*", "mul.vf", false, ev_vector, ev_float, ev_vector, PROG_ID_VERSION, }, - {"*", "mul.dv", OP_MUL_DV, false, + [OP_MUL_DV] = {"*", "mul.dv", false, ev_double, ev_vector, ev_vector, PROG_ID_VERSION, }, - {"*", "mul.vd", OP_MUL_VD, false, + [OP_MUL_VD] = {"*", "mul.vd", false, ev_vector, ev_double, ev_vector, PROG_ID_VERSION, }, - {"*", "mul.q", OP_MUL_Q, false, + [OP_MUL_Q] = {"*", "mul.q", false, ev_quat, ev_quat, ev_quat, PROG_VERSION, }, - {"*", "mul.fq", OP_MUL_FQ, false, + [OP_MUL_FQ] = {"*", "mul.fq", false, ev_float, ev_quat, ev_quat, PROG_VERSION, }, - {"*", "mul.qf", OP_MUL_QF, false, + [OP_MUL_QF] = {"*", "mul.qf", false, ev_quat, ev_float, ev_quat, PROG_VERSION, }, - {"*", "mul.dq", OP_MUL_DQ, false, + [OP_MUL_DQ] = {"*", "mul.dq", false, ev_double, ev_quat, ev_quat, PROG_VERSION, }, - {"*", "mul.qd", OP_MUL_QD, false, + [OP_MUL_QD] = {"*", "mul.qd", false, ev_quat, ev_double, ev_quat, PROG_VERSION, }, - {"*", "mul.qv", OP_MUL_QV, false, + [OP_MUL_QV] = {"*", "mul.qv", false, ev_quat, ev_vector, ev_vector, PROG_VERSION, }, - {"~", "conj.q", OP_CONJ_Q, false, + [OP_CONJ_Q] = {"~", "conj.q", false, ev_quat, ev_invalid, ev_quat, PROG_VERSION, "%Ga, %gc", }, - {"/", "div.f", OP_DIV_F, false, + [OP_DIV_F] = {"/", "div.f", false, ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - {"/", "div.d", OP_DIV_D, false, + [OP_DIV_D] = {"/", "div.d", false, ev_double, ev_double, ev_double, PROG_VERSION, }, - {"%", "rem.d", OP_REM_D, false, + [OP_REM_D] = {"%", "rem.d", false, ev_double, ev_double, ev_double, PROG_VERSION, }, - {"%%", "mod.d", OP_MOD_D, false, + [OP_MOD_D] = {"%%", "mod.d", false, ev_double, ev_double, ev_double, PROG_VERSION, }, - {"+", "add.d", OP_ADD_D, false, + [OP_ADD_D] = {"+", "add.d", false, ev_double, ev_double, ev_double, PROG_VERSION, }, - {"+", "add.f", OP_ADD_F, false, + [OP_ADD_F] = {"+", "add.f", false, ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - {"+", "add.v", OP_ADD_V, false, + [OP_ADD_V] = {"+", "add.v", false, ev_vector, ev_vector, ev_vector, PROG_ID_VERSION, }, - {"+", "add.q", OP_ADD_Q, false, + [OP_ADD_Q] = {"+", "add.q", false, ev_quat, ev_quat, ev_quat, PROG_VERSION, }, - {"+", "add.s", OP_ADD_S, false, + [OP_ADD_S] = {"+", "add.s", false, ev_string, ev_string, ev_string, PROG_VERSION, }, - {"-", "sub.d", OP_SUB_D, false, + [OP_SUB_D] = {"-", "sub.d", false, ev_double, ev_double, ev_double, PROG_VERSION, }, - {"-", "sub.f", OP_SUB_F, false, + [OP_SUB_F] = {"-", "sub.f", false, ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - {"-", "sub.v", OP_SUB_V, false, + [OP_SUB_V] = {"-", "sub.v", false, ev_vector, ev_vector, ev_vector, PROG_ID_VERSION, }, - {"-", "sub.q", OP_SUB_Q, false, + [OP_SUB_Q] = {"-", "sub.q", false, ev_quat, ev_quat, ev_quat, PROG_VERSION, }, - {"==", "eq.d", OP_EQ_D, false, + [OP_EQ_D] = {"==", "eq.d", false, ev_double, ev_double, ev_integer, PROG_VERSION, }, - {"==", "eq.f", OP_EQ_F, false, + [OP_EQ_F] = {"==", "eq.f", false, ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - {"==", "eq.v", OP_EQ_V, false, + [OP_EQ_V] = {"==", "eq.v", false, ev_vector, ev_vector, ev_integer, PROG_ID_VERSION, }, - {"==", "eq.q", OP_EQ_Q, false, + [OP_EQ_Q] = {"==", "eq.q", false, ev_quat, ev_quat, ev_integer, PROG_VERSION, }, - {"==", "eq.s", OP_EQ_S, false, + [OP_EQ_S] = {"==", "eq.s", false, ev_string, ev_string, ev_integer, PROG_ID_VERSION, }, - {"==", "eq.e", OP_EQ_E, false, + [OP_EQ_E] = {"==", "eq.e", false, ev_entity, ev_entity, ev_integer, PROG_ID_VERSION, }, - {"==", "eq.fn", OP_EQ_FN, false, + [OP_EQ_FN] = {"==", "eq.fn", false, ev_func, ev_func, ev_integer, PROG_ID_VERSION, }, - {"!=", "ne.d", OP_NE_D, false, + [OP_NE_D] = {"!=", "ne.d", false, ev_double, ev_double, ev_integer, PROG_VERSION, }, - {"!=", "ne.f", OP_NE_F, false, + [OP_NE_F] = {"!=", "ne.f", false, ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - {"!=", "ne.v", OP_NE_V, false, + [OP_NE_V] = {"!=", "ne.v", false, ev_vector, ev_vector, ev_integer, PROG_ID_VERSION, }, - {"!=", "ne.q", OP_NE_Q, false, + [OP_NE_Q] = {"!=", "ne.q", false, ev_quat, ev_quat, ev_integer, PROG_VERSION, }, - {"!=", "ne.s", OP_NE_S, false, + [OP_NE_S] = {"!=", "ne.s", false, ev_string, ev_string, ev_integer, PROG_ID_VERSION, }, - {"!=", "ne.e", OP_NE_E, false, + [OP_NE_E] = {"!=", "ne.e", false, ev_entity, ev_entity, ev_integer, PROG_ID_VERSION, }, - {"!=", "ne.fn", OP_NE_FN, false, + [OP_NE_FN] = {"!=", "ne.fn", false, ev_func, ev_func, ev_integer, PROG_ID_VERSION, }, - {"<=", "le.d", OP_LE_D, false, + [OP_LE_D] = {"<=", "le.d", false, ev_double, ev_double, ev_integer, PROG_VERSION, }, - {"<=", "le.f", OP_LE_F, false, + [OP_LE_F] = {"<=", "le.f", false, ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - {">=", "ge.d", OP_GE_D, false, + [OP_GE_D] = {">=", "ge.d", false, ev_double, ev_double, ev_integer, PROG_VERSION, }, - {">=", "ge.f", OP_GE_F, false, + [OP_GE_F] = {">=", "ge.f", false, ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - {"<=", "le.s", OP_LE_S, false, + [OP_LE_S] = {"<=", "le.s", false, ev_string, ev_string, ev_integer, PROG_VERSION, }, - {">=", "ge.s", OP_GE_S, false, + [OP_GE_S] = {">=", "ge.s", false, ev_string, ev_string, ev_integer, PROG_VERSION, }, - {"<", "lt.d", OP_LT_D, false, + [OP_LT_D] = {"<", "lt.d", false, ev_double, ev_double, ev_integer, PROG_VERSION, }, - {"<", "lt.f", OP_LT_F, false, + [OP_LT_F] = {"<", "lt.f", false, ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - {">", "gt.d", OP_GT_D, false, + [OP_GT_D] = {">", "gt.d", false, ev_double, ev_double, ev_integer, PROG_VERSION, }, - {">", "gt.f", OP_GT_F, false, + [OP_GT_F] = {">", "gt.f", false, ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - {"<", "lt.s", OP_LT_S, false, + [OP_LT_S] = {"<", "lt.s", false, ev_string, ev_string, ev_integer, PROG_VERSION, }, - {">", "gt.s", OP_GT_S, false, + [OP_GT_S] = {">", "gt.s", false, ev_string, ev_string, ev_integer, PROG_VERSION, }, - {".", "load.f", OP_LOAD_F, false, + [OP_LOAD_F] = {".", "load.f", false, ev_entity, ev_field, ev_float, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc",//FIXME %E more flexible? }, - {".", "load.d", OP_LOAD_D, false, + [OP_LOAD_D] = {".", "load.d", false, ev_entity, ev_field, ev_double, PROG_VERSION, "%Ga.%Gb(%Ec), %gc", }, - {".", "load.v", OP_LOAD_V, false, + [OP_LOAD_V] = {".", "load.v", false, ev_entity, ev_field, ev_vector, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - {".", "load.q", OP_LOAD_Q, false, + [OP_LOAD_Q] = {".", "load.q", false, ev_entity, ev_field, ev_quat, PROG_VERSION, "%Ga.%Gb(%Ec), %gc", }, - {".", "load.s", OP_LOAD_S, false, + [OP_LOAD_S] = {".", "load.s", false, ev_entity, ev_field, ev_string, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - {".", "load.ent", OP_LOAD_ENT, false, + [OP_LOAD_ENT] = {".", "load.ent", false, ev_entity, ev_field, ev_entity, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - {".", "load.fld", OP_LOAD_FLD, false, + [OP_LOAD_FLD] = {".", "load.fld", false, ev_entity, ev_field, ev_field, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - {".", "load.fn", OP_LOAD_FN, false, + [OP_LOAD_FN] = {".", "load.fn", false, ev_entity, ev_field, ev_func, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - {".", "load.i", OP_LOAD_I, false, + [OP_LOAD_I] = {".", "load.i", false, ev_entity, ev_field, ev_integer, PROG_VERSION, "%Ga.%Gb(%Ec), %gc", }, - {".", "load.p", OP_LOAD_P, false, + [OP_LOAD_P] = {".", "load.p", false, ev_entity, ev_field, ev_pointer, PROG_VERSION, "%Ga.%Gb(%Ec), %gc", }, - {".", "loadb.d", OP_LOADB_D, false, + [OP_LOADB_D] = {".", "loadb.d", false, ev_pointer, ev_integer, ev_double, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - {".", "loadb.f", OP_LOADB_F, false, + [OP_LOADB_F] = {".", "loadb.f", false, ev_pointer, ev_integer, ev_float, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - {".", "loadb.v", OP_LOADB_V, false, + [OP_LOADB_V] = {".", "loadb.v", false, ev_pointer, ev_integer, ev_vector, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - {".", "loadb.q", OP_LOADB_Q, false, + [OP_LOADB_Q] = {".", "loadb.q", false, ev_pointer, ev_integer, ev_quat, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - {".", "loadb.s", OP_LOADB_S, false, + [OP_LOADB_S] = {".", "loadb.s", false, ev_pointer, ev_integer, ev_string, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - {".", "loadb.ent", OP_LOADB_ENT, false, + [OP_LOADB_ENT] = {".", "loadb.ent", false, ev_pointer, ev_integer, ev_entity, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - {".", "loadb.fld", OP_LOADB_FLD, false, + [OP_LOADB_FLD] = {".", "loadb.fld", false, ev_pointer, ev_integer, ev_field, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - {".", "loadb.fn", OP_LOADB_FN, false, + [OP_LOADB_FN] = {".", "loadb.fn", false, ev_pointer, ev_integer, ev_func, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - {".", "loadb.i", OP_LOADB_I, false, + [OP_LOADB_I] = {".", "loadb.i", false, ev_pointer, ev_integer, ev_integer, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - {".", "loadb.p", OP_LOADB_P, false, + [OP_LOADB_P] = {".", "loadb.p", false, ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - {".", "loadbi.d", OP_LOADBI_D, false, + [OP_LOADBI_D] = {".", "loadbi.d", false, ev_pointer, ev_short, ev_double, PROG_VERSION, "*(%Ga + %sb), %gc", }, - {".", "loadbi.f", OP_LOADBI_F, false, + [OP_LOADBI_F] = {".", "loadbi.f", false, ev_pointer, ev_short, ev_float, PROG_VERSION, "*(%Ga + %sb), %gc", }, - {".", "loadbi.v", OP_LOADBI_V, false, + [OP_LOADBI_V] = {".", "loadbi.v", false, ev_pointer, ev_short, ev_vector, PROG_VERSION, "*(%Ga + %sb), %gc", }, - {".", "loadbi.q", OP_LOADBI_Q, false, + [OP_LOADBI_Q] = {".", "loadbi.q", false, ev_pointer, ev_short, ev_quat, PROG_VERSION, "*(%Ga + %sb), %gc", }, - {".", "loadbi.s", OP_LOADBI_S, false, + [OP_LOADBI_S] = {".", "loadbi.s", false, ev_pointer, ev_short, ev_string, PROG_VERSION, "*(%Ga + %sb), %gc", }, - {".", "loadbi.ent", OP_LOADBI_ENT, false, + [OP_LOADBI_ENT] = {".", "loadbi.ent", false, ev_pointer, ev_short, ev_entity, PROG_VERSION, "*(%Ga + %sb), %gc", }, - {".", "loadbi.fld", OP_LOADBI_FLD, false, + [OP_LOADBI_FLD] = {".", "loadbi.fld", false, ev_pointer, ev_short, ev_field, PROG_VERSION, "*(%Ga + %sb), %gc", }, - {".", "loadbi.fn", OP_LOADBI_FN, false, + [OP_LOADBI_FN] = {".", "loadbi.fn", false, ev_pointer, ev_short, ev_func, PROG_VERSION, "*(%Ga + %sb), %gc", }, - {".", "loadbi.i", OP_LOADBI_I, false, + [OP_LOADBI_I] = {".", "loadbi.i", false, ev_pointer, ev_short, ev_integer, PROG_VERSION, "*(%Ga + %sb), %gc", }, - {".", "loadbi.p", OP_LOADBI_P, false, + [OP_LOADBI_P] = {".", "loadbi.p", false, ev_pointer, ev_short, ev_pointer, PROG_VERSION, "*(%Ga + %sb), %gc", }, - {"&", "address", OP_ADDRESS, false, + [OP_ADDRESS] = {"&", "address", false, ev_entity, ev_field, ev_pointer, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - {"&", "address", OP_ADDRESS_VOID, false, + [OP_ADDRESS_VOID] = {"&", "address", false, ev_void, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - {"&", "address.d", OP_ADDRESS_D, false, + [OP_ADDRESS_D] = {"&", "address.d", false, ev_double, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - {"&", "address.f", OP_ADDRESS_F, false, + [OP_ADDRESS_F] = {"&", "address.f", false, ev_float, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - {"&", "address.v", OP_ADDRESS_V, false, + [OP_ADDRESS_V] = {"&", "address.v", false, ev_vector, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - {"&", "address.q", OP_ADDRESS_Q, false, + [OP_ADDRESS_Q] = {"&", "address.q", false, ev_quat, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - {"&", "address.s", OP_ADDRESS_S, false, + [OP_ADDRESS_S] = {"&", "address.s", false, ev_string, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - {"&", "address.ent", OP_ADDRESS_ENT, false, + [OP_ADDRESS_ENT] = {"&", "address.ent", false, ev_entity, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - {"&", "address.fld", OP_ADDRESS_FLD, false, + [OP_ADDRESS_FLD] = {"&", "address.fld", false, ev_field, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - {"&", "address.fn", OP_ADDRESS_FN, false, + [OP_ADDRESS_FN] = {"&", "address.fn", false, ev_func, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - {"&", "address.i", OP_ADDRESS_I, false, + [OP_ADDRESS_I] = {"&", "address.i", false, ev_integer, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - {"&", "address.p", OP_ADDRESS_P, false, + [OP_ADDRESS_P] = {"&", "address.p", false, ev_pointer, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - {"&", "lea", OP_LEA, false, + [OP_LEA] = {"&", "lea", false, ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "(%Ga + %Gb), %gc", }, - {"&", "leai", OP_LEAI, false, + [OP_LEAI] = {"&", "leai", false, ev_pointer, ev_short, ev_pointer, PROG_VERSION, "(%Ga + %sb), %gc", }, - {"", "conv.if", OP_CONV_IF, false, + [OP_CONV_IF] = {"", "conv.if", false, ev_integer, ev_invalid, ev_float, PROG_VERSION, "%Ga, %gc", }, - {"", "conv.fi", OP_CONV_FI, false, + [OP_CONV_FI] = {"", "conv.fi", false, ev_float, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - {"", "conv.id", OP_CONV_ID, false, + [OP_CONV_ID] = {"", "conv.id", false, ev_integer, ev_invalid, ev_double, PROG_VERSION, "%Ga, %gc", }, - {"", "conv.di", OP_CONV_DI, false, + [OP_CONV_DI] = {"", "conv.di", false, ev_double, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - {"", "conv.fd", OP_CONV_FD, false, + [OP_CONV_FD] = {"", "conv.fd", false, ev_float, ev_invalid, ev_double, PROG_VERSION, "%Ga, %gc", }, - {"", "conv.df", OP_CONV_DF, false, + [OP_CONV_DF] = {"", "conv.df", false, ev_double, ev_invalid, ev_float, PROG_VERSION, "%Ga, %gc", }, - {"=", "store.d", OP_STORE_D, true, + [OP_STORE_D] = {"=", "store.d", true, ev_double, ev_double, ev_invalid, PROG_VERSION, "%Ga, %gb", }, - {"=", "store.f", OP_STORE_F, true, + [OP_STORE_F] = {"=", "store.f", true, ev_float, ev_float, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - {"=", "store.v", OP_STORE_V, true, + [OP_STORE_V] = {"=", "store.v", true, ev_vector, ev_vector, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - {"=", "store.q", OP_STORE_Q, true, + [OP_STORE_Q] = {"=", "store.q", true, ev_quat, ev_quat, ev_invalid, PROG_VERSION, "%Ga, %gb", }, - {"=", "store.s", OP_STORE_S, true, + [OP_STORE_S] = {"=", "store.s", true, ev_string, ev_string, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - {"=", "store.ent", OP_STORE_ENT, true, + [OP_STORE_ENT] = {"=", "store.ent", true, ev_entity, ev_entity, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - {"=", "store.fld", OP_STORE_FLD, true, + [OP_STORE_FLD] = {"=", "store.fld", true, ev_field, ev_field, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - {"=", "store.fn", OP_STORE_FN, true, + [OP_STORE_FN] = {"=", "store.fn", true, ev_func, ev_func, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - {"=", "store.i", OP_STORE_I, true, + [OP_STORE_I] = {"=", "store.i", true, ev_integer, ev_integer, ev_invalid, PROG_VERSION, "%Ga, %gb", }, - {"=", "store.p", OP_STORE_P, true, + [OP_STORE_P] = {"=", "store.p", true, ev_pointer, ev_pointer, ev_invalid, PROG_VERSION, "%Ga, %gb", }, - {".=", "storep.d", OP_STOREP_D, true, + [OP_STOREP_D] = {".=", "storep.d", true, ev_double, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - {".=", "storep.f", OP_STOREP_F, true, + [OP_STOREP_F] = {".=", "storep.f", true, ev_float, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - {".=", "storep.v", OP_STOREP_V, true, + [OP_STOREP_V] = {".=", "storep.v", true, ev_vector, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - {".=", "storep.q", OP_STOREP_Q, true, + [OP_STOREP_Q] = {".=", "storep.q", true, ev_quat, ev_pointer, ev_invalid, PROG_VERSION, "%Ga, *%Gb", }, - {".=", "storep.s", OP_STOREP_S, true, + [OP_STOREP_S] = {".=", "storep.s", true, ev_string, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - {".=", "storep.ent", OP_STOREP_ENT, true, + [OP_STOREP_ENT] = {".=", "storep.ent", true, ev_entity, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - {".=", "storep.fld", OP_STOREP_FLD, true, + [OP_STOREP_FLD] = {".=", "storep.fld", true, ev_field, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - {".=", "storep.fn", OP_STOREP_FN, true, + [OP_STOREP_FN] = {".=", "storep.fn", true, ev_func, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - {".=", "storep.i", OP_STOREP_I, true, + [OP_STOREP_I] = {".=", "storep.i", true, ev_integer, ev_pointer, ev_invalid, PROG_VERSION, "%Ga, *%Gb", }, - {".=", "storep.p", OP_STOREP_P, true, + [OP_STOREP_P] = {".=", "storep.p", true, ev_pointer, ev_pointer, ev_invalid, PROG_VERSION, "%Ga, *%Gb", }, - {".=", "storeb.d", OP_STOREB_D, true, + [OP_STOREB_D] = {".=", "storeb.d", true, ev_double, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - {".=", "storeb.f", OP_STOREB_F, true, + [OP_STOREB_F] = {".=", "storeb.f", true, ev_float, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - {".=", "storeb.v", OP_STOREB_V, true, + [OP_STOREB_V] = {".=", "storeb.v", true, ev_vector, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - {".=", "storeb.q", OP_STOREB_Q, true, + [OP_STOREB_Q] = {".=", "storeb.q", true, ev_quat, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - {".=", "storeb.s", OP_STOREB_S, true, + [OP_STOREB_S] = {".=", "storeb.s", true, ev_string, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - {".=", "storeb.ent", OP_STOREB_ENT, true, + [OP_STOREB_ENT] = {".=", "storeb.ent", true, ev_entity, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - {".=", "storeb.fld", OP_STOREB_FLD, true, + [OP_STOREB_FLD] = {".=", "storeb.fld", true, ev_field, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - {".=", "storeb.fn", OP_STOREB_FN, true, + [OP_STOREB_FN] = {".=", "storeb.fn", true, ev_func, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - {".=", "storeb.i", OP_STOREB_I, true, + [OP_STOREB_I] = {".=", "storeb.i", true, ev_integer, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - {".=", "storeb.p", OP_STOREB_P, true, + [OP_STOREB_P] = {".=", "storeb.p", true, ev_pointer, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - {".=", "storebi.d", OP_STOREBI_D, true, + [OP_STOREBI_D] = {".=", "storebi.d", true, ev_double, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - {".=", "storebi.f", OP_STOREBI_F, true, + [OP_STOREBI_F] = {".=", "storebi.f", true, ev_float, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - {".=", "storebi.v", OP_STOREBI_V, true, + [OP_STOREBI_V] = {".=", "storebi.v", true, ev_vector, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - {".=", "storebi.q", OP_STOREBI_Q, true, + [OP_STOREBI_Q] = {".=", "storebi.q", true, ev_quat, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - {".=", "storebi.s", OP_STOREBI_S, true, + [OP_STOREBI_S] = {".=", "storebi.s", true, ev_string, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - {".=", "storebi.ent", OP_STOREBI_ENT, true, + [OP_STOREBI_ENT] = {".=", "storebi.ent", true, ev_entity, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - {".=", "storebi.fld", OP_STOREBI_FLD, true, + [OP_STOREBI_FLD] = {".=", "storebi.fld", true, ev_field, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - {".=", "storebi.fn", OP_STOREBI_FN, true, + [OP_STOREBI_FN] = {".=", "storebi.fn", true, ev_func, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - {".=", "storebi.i", OP_STOREBI_I, true, + [OP_STOREBI_I] = {".=", "storebi.i", true, ev_integer, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - {".=", "storebi.p", OP_STOREBI_P, true, + [OP_STOREBI_P] = {".=", "storebi.p", true, ev_pointer, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - {"", "return", OP_RETURN, false, + [OP_RETURN] = {"", "return", false, ev_void, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Ra", }, - {"", "return", OP_RETURN_V, false, + [OP_RETURN_V] = {"", "return", false, ev_invalid, ev_invalid, ev_invalid, PROG_VERSION, "", }, - {"!", "not.d", OP_NOT_D, false, + [OP_NOT_D] = {"!", "not.d", false, ev_double, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - {"!", "not.f", OP_NOT_F, false, + [OP_NOT_F] = {"!", "not.f", false, ev_float, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - {"!", "not.v", OP_NOT_V, false, + [OP_NOT_V] = {"!", "not.v", false, ev_vector, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - {"!", "not.q", OP_NOT_Q, false, + [OP_NOT_Q] = {"!", "not.q", false, ev_quat, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - {"!", "not.s", OP_NOT_S, false, + [OP_NOT_S] = {"!", "not.s", false, ev_string, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - {"!", "not.ent", OP_NOT_ENT, false, + [OP_NOT_ENT] = {"!", "not.ent", false, ev_entity, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - {"!", "not.fn", OP_NOT_FN, false, + [OP_NOT_FN] = {"!", "not.fn", false, ev_func, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - {"!", "not.p", OP_NOT_P, false, + [OP_NOT_P] = {"!", "not.p", false, ev_pointer, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - {"", "if", OP_IF, false, + [OP_IF] = {"", "if", false, ev_integer, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", }, - {"", "ifnot", OP_IFNOT, false, + [OP_IFNOT] = {"", "ifnot", false, ev_integer, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", }, - {"", "ifbe", OP_IFBE, true, + [OP_IFBE] = {"", "ifbe", true, ev_integer, ev_short, ev_invalid, PROG_VERSION, "%Ga branch %sb (%Ob)", }, - {"", "ifb", OP_IFB, true, + [OP_IFB] = {"", "ifb", true, ev_integer, ev_short, ev_invalid, PROG_VERSION, "%Ga branch %sb (%Ob)", }, - {"", "ifae", OP_IFAE, true, + [OP_IFAE] = {"", "ifae", true, ev_integer, ev_short, ev_invalid, PROG_VERSION, "%Ga branch %sb (%Ob)", }, - {"", "ifa", OP_IFA, true, + [OP_IFA] = {"", "ifa", true, ev_integer, ev_short, ev_invalid, PROG_VERSION, "%Ga branch %sb (%Ob)", }, // calls returns REG_RETURN - {"", "call0", OP_CALL0, false, + [OP_CALL0] = {"", "call0", false, ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa ()", }, - {"", "call1", OP_CALL1, false, + [OP_CALL1] = {"", "call1", false, ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x)", }, - {"", "call2", OP_CALL2, false, + [OP_CALL2] = {"", "call2", false, ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x)", }, - {"", "call3", OP_CALL3, false, + [OP_CALL3] = {"", "call3", false, ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x)", }, - {"", "call4", OP_CALL4, false, + [OP_CALL4] = {"", "call4", false, ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x)", }, - {"", "call5", OP_CALL5, false, + [OP_CALL5] = {"", "call5", false, ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x)", }, - {"", "call6", OP_CALL6, false, + [OP_CALL6] = {"", "call6", false, ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x)", }, - {"", "call7", OP_CALL7, false, + [OP_CALL7] = {"", "call7", false, ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x, %P6x)", }, - {"", "call8", OP_CALL8, false, + [OP_CALL8] = {"", "call8", false, ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x, %P6x, %P7x)", }, - {"", "rcall1", OP_RCALL1, false, + [OP_RCALL0] = {"", 0, false, + ev_invalid, ev_invalid, ev_invalid, + ~0, // not a valid instruction + 0, + }, + [OP_RCALL1] = {"", "rcall1", false, ev_func, ev_void, ev_invalid, PROG_VERSION, "%Fa (%P0b)", }, - {"", "rcall2", OP_RCALL2, false, + [OP_RCALL2] = {"", "rcall2", false, ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c)", }, - {"", "rcall3", OP_RCALL3, false, + [OP_RCALL3] = {"", "rcall3", false, ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x)", }, - {"", "rcall4", OP_RCALL4, false, + [OP_RCALL4] = {"", "rcall4", false, ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x)", }, - {"", "rcall5", OP_RCALL5, false, + [OP_RCALL5] = {"", "rcall5", false, ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x)", }, - {"", "rcall6", OP_RCALL6, false, + [OP_RCALL6] = {"", "rcall6", false, ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x)", }, - {"", "rcall7", OP_RCALL7, false, + [OP_RCALL7] = {"", "rcall7", false, ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x)", }, - {"", "rcall8", OP_RCALL8, false, + [OP_RCALL8] = {"", "rcall8", false, ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x, %P7x)", }, - {"", "state", OP_STATE, false, + [OP_STATE] = {"", "state", false, ev_float, ev_func, ev_invalid, PROG_ID_VERSION, "%Ga, %Gb", }, - {"", "state.f", OP_STATE_F, false, + [OP_STATE_F] = {"", "state.f", false, ev_float, ev_func, ev_float, PROG_VERSION, "%Ga, %Gb, %Gc", }, - {"", "goto", OP_GOTO, false, + [OP_GOTO] = {"", "goto", false, ev_short, ev_invalid, ev_invalid, PROG_ID_VERSION, "branch %sa (%Oa)", }, - {"", "jump", OP_JUMP, false, + [OP_JUMP] = {"", "jump", false, ev_integer, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - {"", "jumpb", OP_JUMPB, false, + [OP_JUMPB] = {"", "jumpb", false, ev_void, ev_integer, ev_invalid, PROG_VERSION, "%Ga[%Gb]", }, - {"&&", "and.f", OP_AND, false, + [OP_AND] = {"&&", "and.f", false, ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - {"||", "or.f", OP_OR, false, + [OP_OR] = {"||", "or.f", false, ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - {"<<", "shl.f", OP_SHL_F, false, + [OP_SHL_F] = {"<<", "shl.f", false, ev_float, ev_float, ev_float, PROG_VERSION, }, - {">>", "shr.f", OP_SHR_F, false, + [OP_SHR_F] = {">>", "shr.f", false, ev_float, ev_float, ev_float, PROG_VERSION, }, - {"<<", "shl.i", OP_SHL_I, false, + [OP_SHL_I] = {"<<", "shl.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {">>", "shr.i", OP_SHR_I, false, + [OP_SHR_I] = {">>", "shr.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {">>", "shr.u", OP_SHR_U, false, + [OP_SHR_U] = {">>", "shr.u", false, ev_uinteger, ev_integer, ev_uinteger, PROG_VERSION, }, - {"&", "bitand", OP_BITAND, false, + [OP_BITAND] = {"&", "bitand", false, ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - {"|", "bitor", OP_BITOR, false, + [OP_BITOR] = {"|", "bitor", false, ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - {"+", "add.i", OP_ADD_I, false, + [OP_ADD_I] = {"+", "add.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"-", "sub.i", OP_SUB_I, false, + [OP_SUB_I] = {"-", "sub.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"*", "mul.i", OP_MUL_I, false, + [OP_MUL_I] = {"*", "mul.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"/", "div.i", OP_DIV_I, false, + [OP_DIV_I] = {"/", "div.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"%", "rem.i", OP_REM_I, false, + [OP_REM_I] = {"%", "rem.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"%%", "mod.i", OP_MOD_I, false, + [OP_MOD_I] = {"%%", "mod.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"&", "bitand.i", OP_BITAND_I, false, + [OP_BITAND_I] = {"&", "bitand.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"|", "bitor.i", OP_BITOR_I, false, + [OP_BITOR_I] = {"|", "bitor.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"%", "rem.f", OP_REM_F, false, + [OP_REM_F] = {"%", "rem.f", false, ev_float, ev_float, ev_float, PROG_VERSION, }, - {"%%", "mod.f", OP_MOD_F, false, + [OP_MOD_F] = {"%%", "mod.f", false, ev_float, ev_float, ev_float, PROG_VERSION, }, - {">=", "ge.i", OP_GE_I, false, + [OP_GE_I] = {">=", "ge.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"<=", "le.i", OP_LE_I, false, + [OP_LE_I] = {"<=", "le.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {">", "gt.i", OP_GT_I, false, + [OP_GT_I] = {">", "gt.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"<", "lt.i", OP_LT_I, false, + [OP_LT_I] = {"<", "lt.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"&&", "and.i", OP_AND_I, false, + [OP_AND_I] = {"&&", "and.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"||", "or.i", OP_OR_I, false, + [OP_OR_I] = {"||", "or.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"!", "not.i", OP_NOT_I, false, + [OP_NOT_I] = {"!", "not.i", false, ev_integer, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - {"==", "eq.i", OP_EQ_I, false, + [OP_EQ_I] = {"==", "eq.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"!=", "ne.i", OP_NE_I, false, + [OP_NE_I] = {"!=", "ne.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {">=", "ge.u", OP_GE_U, false, + [OP_GE_U] = {">=", "ge.u", false, ev_uinteger, ev_uinteger, ev_integer, PROG_VERSION, }, - {"<=", "le.u", OP_LE_U, false, + [OP_LE_U] = {"<=", "le.u", false, ev_uinteger, ev_uinteger, ev_integer, PROG_VERSION, }, - {">", "gt.u", OP_GT_U, false, + [OP_GT_U] = {">", "gt.u", false, ev_uinteger, ev_uinteger, ev_integer, PROG_VERSION, }, - {"<", "lt.u", OP_LT_U, false, + [OP_LT_U] = {"<", "lt.u", false, ev_uinteger, ev_uinteger, ev_integer, PROG_VERSION, }, - {"^", "bitxor.f", OP_BITXOR_F, false, + [OP_BITXOR_F] = {"^", "bitxor.f", false, ev_float, ev_float, ev_float, PROG_VERSION, }, - {"~", "bitnot.f", OP_BITNOT_F, false, + [OP_BITNOT_F] = {"~", "bitnot.f", false, ev_float, ev_invalid, ev_float, PROG_VERSION, "%Ga, %gc", }, - {"^", "bitxor.i", OP_BITXOR_I, false, + [OP_BITXOR_I] = {"^", "bitxor.i", false, ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - {"~", "bitnot.i", OP_BITNOT_I, false, + [OP_BITNOT_I] = {"~", "bitnot.i", false, ev_integer, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - {">=", "ge.p", OP_GE_P, false, + [OP_GE_P] = {">=", "ge.p", false, ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - {"<=", "le.p", OP_LE_P, false, + [OP_LE_P] = {"<=", "le.p", false, ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - {">", "gt.p", OP_GT_P, false, + [OP_GT_P] = {">", "gt.p", false, ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - {"<", "lt.p", OP_LT_P, false, + [OP_LT_P] = {"<", "lt.p", false, ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - {"==", "eq.p", OP_EQ_P, false, + [OP_EQ_P] = {"==", "eq.p", false, ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - {"!=", "ne.p", OP_NE_P, false, + [OP_NE_P] = {"!=", "ne.p", false, ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - {"", "movei", OP_MOVEI, true, + [OP_MOVEI] = {"", "movei", true, ev_void, ev_short, ev_void, PROG_VERSION, "%Ga, %sb, %gc", }, - {"", "movep", OP_MOVEP, true, + [OP_MOVEP] = {"", "movep", true, ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "%Ga, %Gb, %Gc", }, - {"", "movepi", OP_MOVEPI, true, + [OP_MOVEPI] = {"", "movepi", true, ev_pointer, ev_short, ev_pointer, PROG_VERSION, "%Ga, %sb, %Gc", }, - {"", "memseti", OP_MEMSETI, true, + [OP_MEMSETI] = {"", "memseti", true, ev_integer, ev_short, ev_void, PROG_VERSION, "%Ga, %sb, %gc", }, - {"", "memsetp", OP_MEMSETP, true, + [OP_MEMSETP] = {"", "memsetp", true, ev_integer, ev_integer, ev_pointer, PROG_VERSION, "%Ga, %Gb, %Gc", }, - {"", "memsetpi", OP_MEMSETPI, true, + [OP_MEMSETPI] = {"", "memsetpi", true, ev_integer, ev_short, ev_pointer, PROG_VERSION, "%Ga, %sb, %Gc", }, - {"", "push.s", OP_PUSH_S, false, + [OP_PUSH_S] = {"", "push.s", false, ev_string, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - {"", "push.f", OP_PUSH_F, false, + [OP_PUSH_F] = {"", "push.f", false, ev_float, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - {"", "push.v", OP_PUSH_V, false, + [OP_PUSH_V] = {"", "push.v", false, ev_vector, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - {"", "push.ent", OP_PUSH_ENT, false, + [OP_PUSH_ENT] = {"", "push.ent", false, ev_entity, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - {"", "push.fld", OP_PUSH_FLD, false, + [OP_PUSH_FLD] = {"", "push.fld", false, ev_field, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - {"", "push.fn", OP_PUSH_FN, false, + [OP_PUSH_FN] = {"", "push.fn", false, ev_func, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - {"", "push.p", OP_PUSH_P, false, + [OP_PUSH_P] = {"", "push.p", false, ev_pointer, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - {"", "push.q", OP_PUSH_Q, false, + [OP_PUSH_Q] = {"", "push.q", false, ev_quat, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - {"", "push.i", OP_PUSH_I, false, + [OP_PUSH_I] = {"", "push.i", false, ev_integer, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, + [OP_PUSH_D] = {"", "push.d", false, + ev_double, ev_invalid, ev_invalid, + PROG_VERSION, + "%Ga", + }, - {"", "pushb.s", OP_PUSHB_S, false, + [OP_PUSHB_S] = {"", "pushb.s", false, ev_pointer, ev_integer, ev_string, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "pushb.f", OP_PUSHB_F, false, + [OP_PUSHB_F] = {"", "pushb.f", false, ev_pointer, ev_integer, ev_float, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "pushb.v", OP_PUSHB_V, false, + [OP_PUSHB_V] = {"", "pushb.v", false, ev_pointer, ev_integer, ev_vector, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "pushb.ent", OP_PUSHB_ENT, false, + [OP_PUSHB_ENT] = {"", "pushb.ent", false, ev_pointer, ev_integer, ev_entity, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "pushb.fld", OP_PUSHB_FLD, false, + [OP_PUSHB_FLD] = {"", "pushb.fld", false, ev_pointer, ev_integer, ev_field, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "pushb.fn", OP_PUSHB_FN, false, + [OP_PUSHB_FN] = {"", "pushb.fn", false, ev_pointer, ev_integer, ev_func, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "pushb.p", OP_PUSHB_P, false, + [OP_PUSHB_P] = {"", "pushb.p", false, ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "pushb.q", OP_PUSHB_Q, false, + [OP_PUSHB_Q] = {"", "pushb.q", false, ev_pointer, ev_integer, ev_quat, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "pushb.i", OP_PUSHB_I, false, + [OP_PUSHB_I] = {"", "pushb.i", false, ev_pointer, ev_integer, ev_integer, PROG_VERSION, "*(%Ga + %Gb)", }, + [OP_PUSHB_D] = {"", "pushb.d", false, + ev_pointer, ev_integer, ev_double, + PROG_VERSION, + "*(%Ga + %Gb)", + }, - {"", "pushbi.s", OP_PUSHBI_S, false, + [OP_PUSHBI_S] = {"", "pushbi.s", false, ev_pointer, ev_short, ev_string, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "pushbi.f", OP_PUSHBI_F, false, + [OP_PUSHBI_F] = {"", "pushbi.f", false, ev_pointer, ev_short, ev_float, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "pushbi.v", OP_PUSHBI_V, false, + [OP_PUSHBI_V] = {"", "pushbi.v", false, ev_pointer, ev_short, ev_vector, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "pushbi.ent", OP_PUSHBI_ENT, false, + [OP_PUSHBI_ENT] = {"", "pushbi.ent", false, ev_pointer, ev_short, ev_entity, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "pushbi.fld", OP_PUSHBI_FLD, false, + [OP_PUSHBI_FLD] = {"", "pushbi.fld", false, ev_pointer, ev_short, ev_field, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "pushbi.fn", OP_PUSHBI_FN, false, + [OP_PUSHBI_FN] = {"", "pushbi.fn", false, ev_pointer, ev_short, ev_func, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "pushbi.p", OP_PUSHBI_P, false, + [OP_PUSHBI_P] = {"", "pushbi.p", false, ev_pointer, ev_short, ev_pointer, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "pushbi.q", OP_PUSHBI_Q, false, + [OP_PUSHBI_Q] = {"", "pushbi.q", false, ev_pointer, ev_short, ev_quat, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "pushbi.i", OP_PUSHBI_I, false, + [OP_PUSHBI_I] = {"", "pushbi.i", false, ev_pointer, ev_short, ev_integer, PROG_VERSION, "*(%Ga + %sb)", }, + [OP_PUSHBI_D] = {"", "pushbi.d", false, + ev_pointer, ev_short, ev_double, + PROG_VERSION, + "*(%Ga + %sb)", + }, - {"", "pop.s", OP_POP_S, false, + [OP_POP_S] = {"", "pop.s", false, ev_string, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - {"", "pop.f", OP_POP_F, false, + [OP_POP_F] = {"", "pop.f", false, ev_float, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - {"", "pop.v", OP_POP_V, false, + [OP_POP_V] = {"", "pop.v", false, ev_vector, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - {"", "pop.ent", OP_POP_ENT, false, + [OP_POP_ENT] = {"", "pop.ent", false, ev_entity, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - {"", "pop.fld", OP_POP_FLD, false, + [OP_POP_FLD] = {"", "pop.fld", false, ev_field, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - {"", "pop.fn", OP_POP_FN, false, + [OP_POP_FN] = {"", "pop.fn", false, ev_func, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - {"", "pop.p", OP_POP_P, false, + [OP_POP_P] = {"", "pop.p", false, ev_pointer, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - {"", "pop.q", OP_POP_Q, false, + [OP_POP_Q] = {"", "pop.q", false, ev_quat, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - {"", "pop.i", OP_POP_I, false, + [OP_POP_I] = {"", "pop.i", false, ev_integer, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, + [OP_POP_D] = {"", "pop.d", false, + ev_double, ev_invalid, ev_invalid, + PROG_VERSION, + "%ga", + }, - {"", "popb.s", OP_POPB_S, false, + [OP_POPB_S] = {"", "popb.s", false, ev_pointer, ev_integer, ev_string, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "popb.f", OP_POPB_F, false, + [OP_POPB_F] = {"", "popb.f", false, ev_pointer, ev_integer, ev_float, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "popb.v", OP_POPB_V, false, + [OP_POPB_V] = {"", "popb.v", false, ev_pointer, ev_integer, ev_vector, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "popb.ent", OP_POPB_ENT, false, + [OP_POPB_ENT] = {"", "popb.ent", false, ev_pointer, ev_integer, ev_entity, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "popb.fld", OP_POPB_FLD, false, + [OP_POPB_FLD] = {"", "popb.fld", false, ev_pointer, ev_integer, ev_field, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "popb.fn", OP_POPB_FN, false, + [OP_POPB_FN] = {"", "popb.fn", false, ev_pointer, ev_integer, ev_func, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "popb.p", OP_POPB_P, false, + [OP_POPB_P] = {"", "popb.p", false, ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "popb.q", OP_POPB_Q, false, + [OP_POPB_Q] = {"", "popb.q", false, ev_pointer, ev_integer, ev_quat, PROG_VERSION, "*(%Ga + %Gb)", }, - {"", "popb.i", OP_POPB_I, false, + [OP_POPB_I] = {"", "popb.i", false, ev_pointer, ev_integer, ev_integer, PROG_VERSION, "*(%Ga + %Gb)", }, + [OP_POPB_D] = {"", "popb.d", false, + ev_pointer, ev_integer, ev_double, + PROG_VERSION, + "*(%Ga + %Gb)", + }, - {"", "popbi.s", OP_POPBI_S, false, + [OP_POPBI_S] = {"", "popbi.s", false, ev_pointer, ev_short, ev_string, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "popbi.f", OP_POPBI_F, false, + [OP_POPBI_F] = {"", "popbi.f", false, ev_pointer, ev_short, ev_float, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "popbi.v", OP_POPBI_V, false, + [OP_POPBI_V] = {"", "popbi.v", false, ev_pointer, ev_short, ev_vector, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "popbi.ent", OP_POPBI_ENT, false, + [OP_POPBI_ENT] = {"", "popbi.ent", false, ev_pointer, ev_short, ev_entity, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "popbi.fld", OP_POPBI_FLD, false, + [OP_POPBI_FLD] = {"", "popbi.fld", false, ev_pointer, ev_short, ev_field, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "popbi.fn", OP_POPBI_FN, false, + [OP_POPBI_FN] = {"", "popbi.fn", false, ev_pointer, ev_short, ev_func, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "popbi.p", OP_POPBI_P, false, + [OP_POPBI_P] = {"", "popbi.p", false, ev_pointer, ev_short, ev_pointer, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "popbi.q", OP_POPBI_Q, false, + [OP_POPBI_Q] = {"", "popbi.q", false, ev_pointer, ev_short, ev_quat, PROG_VERSION, "*(%Ga + %sb)", }, - {"", "popbi.i", OP_POPBI_I, false, + [OP_POPBI_I] = {"", "popbi.i", false, ev_pointer, ev_short, ev_integer, PROG_VERSION, "*(%Ga + %sb)", }, + [OP_POPBI_D] = {"", "popbi.d", false, + ev_pointer, ev_short, ev_double, + PROG_VERSION, + "*(%Ga + %sb)", + }, // end of table - {0}, + [OP_MEMSETPI+1] = {0}, //XXX FIXME relies on OP_MEMSETPI being last }; - -static uintptr_t -opcode_get_hash (const void *op, void *unused) -{ - return ((opcode_t *)op)->opcode; -} - -static int -opcode_compare (const void *_opa, const void *_opb, void *unused) -{ - opcode_t *opa = (opcode_t *)_opa; - opcode_t *opb = (opcode_t *)_opb; - - return opa->opcode == opb->opcode; -} - -opcode_t * +const opcode_t * PR_Opcode (pr_short_t opcode) { - opcode_t op; - - op.opcode = opcode; - return Hash_FindElement (opcode_table, &op); + if (opcode < 0 + || opcode >= (int) (sizeof (pr_opcodes) / sizeof (pr_opcodes[0])) - 1) { + return 0; + } + return &pr_opcodes[opcode]; } VISIBLE void PR_Opcode_Init (void) { - const opcode_t *op; - - if (opcode_table) { - // already initialized - return; - } - opcode_table = Hash_NewTable (1021, 0, 0, 0, 0); - Hash_SetHashCompare (opcode_table, opcode_get_hash, opcode_compare); - - for (op = pr_opcodes; op->name; op++) { - Hash_AddElement (opcode_table, (void *) op); - } } static inline void -check_branch (progs_t *pr, dstatement_t *st, opcode_t *op, short offset) +check_branch (progs_t *pr, dstatement_t *st, const opcode_t *op, short offset) { pr_int_t address = st - pr->pr_statements; @@ -1551,7 +1556,7 @@ is_vector_parameter_store (progs_t *pr, dstatement_t *st, #define ISDENORM(x) ((x) && !((x) & 0x7f800000)) static inline void -check_global (progs_t *pr, dstatement_t *st, opcode_t *op, etype_t type, +check_global (progs_t *pr, dstatement_t *st, const opcode_t *op, etype_t type, unsigned short operand, int check_denorm) { const char *msg; @@ -1609,7 +1614,7 @@ error: } static void -check_global_size (progs_t *pr, dstatement_t *st, opcode_t *op, +check_global_size (progs_t *pr, dstatement_t *st, const opcode_t *op, unsigned short size, unsigned short operand) { const char *msg; @@ -1627,7 +1632,7 @@ error: int PR_Check_Opcodes (progs_t *pr) { - opcode_t *op; + const opcode_t *op; dstatement_t *st; int state_ok = 0; int pushpop_ok = 0; @@ -1784,7 +1789,7 @@ PR_Check_Opcodes (progs_t *pr) default: check_global (pr, st, op, op->type_a, st->a, 1); check_global (pr, st, op, op->type_b, st->b, - op->opcode != OP_STORE_F); + (op - pr_opcodes) != OP_STORE_F); check_global (pr, st, op, op->type_c, st->c, 0); break; } diff --git a/tools/qfcc/include/opcodes.h b/tools/qfcc/include/opcodes.h index 779370340..2ffbe04c8 100644 --- a/tools/qfcc/include/opcodes.h +++ b/tools/qfcc/include/opcodes.h @@ -48,6 +48,8 @@ extern struct opcode_s *op_jumpb; struct operand_s; +extern struct opcode_s *opcode_map; + struct opcode_s *opcode_find (const char *name, struct operand_s *op_a, struct operand_s *op_b, struct operand_s *op_c); void opcode_init (void); diff --git a/tools/qfcc/source/emit.c b/tools/qfcc/source/emit.c index 5a7dd129a..c2dac98ec 100644 --- a/tools/qfcc/source/emit.c +++ b/tools/qfcc/source/emit.c @@ -213,7 +213,7 @@ emit_statement (statement_t *statement) } } s = codespace_newstatement (pr.code); - s->op = op->opcode; + s->op = op - opcode_map; s->a = def_a ? def_a->offset : 0; s->b = def_b ? def_b->offset : 0; s->c = def_c ? def_c->offset : 0; diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index a9bda7a3c..bf962ec96 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -49,6 +49,7 @@ hashtab_t *opcode_type_table; hashtab_t *opcode_void_table; +opcode_t *opcode_map; #define ROTL(x,n) ((((unsigned)(x))<<(n))|((unsigned)(x))>>(32-n)) @@ -95,7 +96,7 @@ opcode_t * opcode_find (const char *name, operand_t *op_a, operand_t *op_b, operand_t *op_c) { - opcode_t search_op; + opcode_t search_op = {}; opcode_t *op; opcode_t *sop; void **op_list; @@ -122,12 +123,6 @@ opcode_find (const char *name, operand_t *op_a, operand_t *op_b, return op; } -static void -opcode_free (void *_op, void *unused) -{ - free (_op); -} - void opcode_init (void) { @@ -139,14 +134,23 @@ opcode_init (void) Hash_FlushTable (opcode_type_table); } else { PR_Opcode_Init (); - opcode_type_table = Hash_NewTable (1021, 0, opcode_free, 0, 0); + opcode_type_table = Hash_NewTable (1021, 0, 0, 0, 0); Hash_SetHashCompare (opcode_type_table, get_hash, compare); opcode_void_table = Hash_NewTable (1021, get_key, 0, 0, 0); } + + int num_opcodes = 0; for (op = pr_opcodes; op->name; op++) { + num_opcodes++; + } + if (!opcode_map) { + opcode_map = calloc (num_opcodes, sizeof (opcode_t)); + } + for (int i = 0; i < num_opcodes; i++) { + op = pr_opcodes + i; if (op->min_version > options.code.progsversion) continue; - mop = malloc (sizeof (opcode_t)); + mop = opcode_map + i; *mop = *op; if (options.code.progsversion == PROG_ID_VERSION) { // v6 progs have no concept of integer, but the QF engine From 97034d9dde9dae7aa95412f543366e0d80f0c2f6 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 2 Jan 2022 00:57:55 +0900 Subject: [PATCH 004/360] [simd] Add 2d vector types For int, long, float and double. I've been meaning to add them for a while, and they're part of the new Ruamoko instructions set (which is progressing nicely). --- include/QF/simd/types.h | 22 +++-- include/QF/simd/vec2d.h | 115 +++++++++++++++++++++++++ include/QF/simd/vec2f.h | 166 +++++++++++++++++++++++++++++++++++++ include/QF/simd/vec4d.h | 49 ++++++++--- include/QF/simd/vec4f.h | 59 +++++++++---- libs/util/cexpr-type.c | 4 +- libs/util/simd.c | 4 + libs/util/test/test-simd.c | 16 ++-- tools/qfvis/source/flow.c | 4 +- 9 files changed, 395 insertions(+), 44 deletions(-) create mode 100644 include/QF/simd/vec2d.h create mode 100644 include/QF/simd/vec2f.h diff --git a/include/QF/simd/types.h b/include/QF/simd/types.h index 5764fe085..ad8345f44 100644 --- a/include/QF/simd/types.h +++ b/include/QF/simd/types.h @@ -30,7 +30,8 @@ #include -#define VEC_TYPE(t,n) typedef t n __attribute__ ((vector_size (4*sizeof (t)))) +#define VEC_TYPE(t,n,s) \ + typedef t n __attribute__ ((vector_size (s*sizeof (t)))) /** Three element vector type for interfacing with compact data. * @@ -39,6 +40,9 @@ */ typedef double vec3d_t[3]; +VEC_TYPE (double, vec2d_t, 2); +VEC_TYPE (int64_t, vec2l_t, 2); + #ifdef __AVX2__ /** Four element vector type for horizontal (AOS) vector data. * @@ -49,11 +53,11 @@ typedef double vec3d_t[3]; * a single component from four vectors, or a single row/column (depending on * context) of an Nx4 or 4xN matrix. */ -VEC_TYPE (double, vec4d_t); +VEC_TYPE (double, vec4d_t, 4); /** Used mostly for __builtin_shuffle. */ -VEC_TYPE (int64_t, vec4l_t); +VEC_TYPE (int64_t, vec4l_t, 4); #endif /** Three element vector type for interfacing with compact data. @@ -63,6 +67,9 @@ VEC_TYPE (int64_t, vec4l_t); */ typedef float vec3f_t[3]; +VEC_TYPE (float, vec2f_t, 2); +VEC_TYPE (int, vec2i_t, 2); + /** Four element vector type for horizontal (AOS) vector data. * * This is used for both vectors (3D and 4D) and quaternions. 3D vectors @@ -72,20 +79,25 @@ typedef float vec3f_t[3]; * a single component from four vectors, or a single row/column (depending on * context) of an Nx4 or 4xN matrix. */ -VEC_TYPE (float, vec4f_t); +VEC_TYPE (float, vec4f_t, 4); /** Used mostly for __builtin_shuffle. */ -VEC_TYPE (int, vec4i_t); +VEC_TYPE (int, vec4i_t, 4); +#define VEC2D_FMT "[%.17g, %.17g]" +#define VEC2L_FMT "[%ld, %ld]" #define VEC4D_FMT "[%.17g, %.17g, %.17g, %.17g]" #if __WORDSIZE == 64 #define VEC4L_FMT "[%ld, %ld, %ld, %ld]" #else #define VEC4L_FMT "[%lld, %lld, %lld, %lld]" #endif +#define VEC2F_FMT "[%.9g, %.9g]" +#define VEC2I_FMT "[%d, %d]" #define VEC4F_FMT "[%.9g, %.9g, %.9g, %.9g]" #define VEC4I_FMT "[%d, %d, %d, %d]" +#define VEC2_EXP(v) (v)[0], (v)[1] #define VEC4_EXP(v) (v)[0], (v)[1], (v)[2], (v)[3] #define MAT4_ROW(m, r) (m)[0][r], (m)[1][r], (m)[2][r], (m)[3][r] diff --git a/include/QF/simd/vec2d.h b/include/QF/simd/vec2d.h new file mode 100644 index 000000000..6b50ea6b4 --- /dev/null +++ b/include/QF/simd/vec2d.h @@ -0,0 +1,115 @@ +/* + QF/simd/vec2d.h + + Vector functions for vec2d_t (ie, double precision) + + Copyright (C) 2020 Bill Currie + Copyright (C) 2022 Bill Currie + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + +*/ + +#ifndef __QF_simd_vec2d_h +#define __QF_simd_vec2d_h + +#include + +#include "QF/simd/types.h" + +GNU89INLINE inline vec2d_t vsqrt2d (vec2d_t v) __attribute__((const)); +GNU89INLINE inline vec2d_t vceil2d (vec2d_t v) __attribute__((const)); +GNU89INLINE inline vec2d_t vfloor2d (vec2d_t v) __attribute__((const)); +GNU89INLINE inline vec2d_t vtrunc2d (vec2d_t v) __attribute__((const)); +/** 2D vector dot product. + */ +GNU89INLINE inline vec2d_t dot2d (vec2d_t a, vec2d_t b) __attribute__((const)); +GNU89INLINE inline vec2d_t cmuld (vec2d_t a, vec2d_t b) __attribute__((const)); + +#ifndef IMPLEMENT_VEC2D_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2d_t +vsqrt2d (vec2d_t v) +{ + return _mm_sqrt_pd (v); +} + +#ifndef IMPLEMENT_VEC2D_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2d_t +vceil2d (vec2d_t v) +{ + return _mm_ceil_pd (v); +} + +#ifndef IMPLEMENT_VEC2D_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2d_t +vfloor2d (vec2d_t v) +{ + return _mm_floor_pd (v); +} + +#ifndef IMPLEMENT_VEC2D_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2d_t +vtrunc2d (vec2d_t v) +{ + return _mm_round_pd (v, _MM_FROUND_TRUNC); +} + +#ifndef IMPLEMENT_VEC2D_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2d_t +dot2d (vec2d_t a, vec2d_t b) +{ + vec2d_t c = a * b; + c = _mm_hadd_pd (c, c); + return c; +} + +#ifndef IMPLEMENT_VEC2F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2d_t +cmuld (vec2d_t a, vec2d_t b) +{ + vec2d_t c = a * b[0]; + c = _mm_addsub_pd (c, (vec2d_t) { c[1], c[0] }); + return c; +} + +#endif//__QF_simd_vec2d_h diff --git a/include/QF/simd/vec2f.h b/include/QF/simd/vec2f.h new file mode 100644 index 000000000..ffa403ad4 --- /dev/null +++ b/include/QF/simd/vec2f.h @@ -0,0 +1,166 @@ +/* + QF/simd/vec2f.h + + Vector functions for vec2f_t (ie, float precision) + + Copyright (C) 2020 Bill Currie + Copyright (C) 2022 Bill Currie + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + +*/ + +#ifndef __QF_simd_vec2f_h +#define __QF_simd_vec2f_h + +#include +#include + +#include "QF/simd/types.h" + +GNU89INLINE inline vec2f_t vabs2f (vec2f_t v) __attribute__((const)); +GNU89INLINE inline vec2f_t vsqrt2f (vec2f_t v) __attribute__((const)); +GNU89INLINE inline vec2f_t vceil2f (vec2f_t v) __attribute__((const)); +GNU89INLINE inline vec2f_t vfloor2f (vec2f_t v) __attribute__((const)); +GNU89INLINE inline vec2f_t vtrunc2f (vec2f_t v) __attribute__((const)); +/** 2D vector dot product. + */ +GNU89INLINE inline vec2f_t dot2f (vec2f_t a, vec2f_t b) __attribute__((const)); +GNU89INLINE inline vec2f_t cmulf (vec2f_t a, vec2f_t b) __attribute__((const)); +GNU89INLINE inline vec2f_t normal2f (vec2f_t v) __attribute__((pure)); +GNU89INLINE inline vec2f_t magnitude2f (vec2f_t v) __attribute__((pure)); + +#ifndef IMPLEMENT_VEC2F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2f_t +vabs2f (vec2f_t v) +{ + const uint32_t nan = ~0u >> 1; + const vec2i_t abs = { nan, nan }; + return (vec2f_t) ((vec2i_t) v & abs); +} + +#ifndef IMPLEMENT_VEC2F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2f_t +vsqrt2f (vec2f_t v) +{ + vec4f_t t = { v[0], v[1], 0, 0 }; + t = _mm_sqrt_ps (t); + return (vec2f_t) { t[0], t[1] }; +} + +#ifndef IMPLEMENT_VEC2F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2f_t +vceil2f (vec2f_t v) +{ + vec4f_t t = { v[0], v[1], 0, 0 }; + t = _mm_ceil_ps (t); + return (vec2f_t) { t[0], t[1] }; +} + +#ifndef IMPLEMENT_VEC2F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2f_t +vfloor2f (vec2f_t v) +{ + vec4f_t t = { v[0], v[1], 0, 0 }; + t = _mm_floor_ps (t); + return (vec2f_t) { t[0], t[1] }; +} + +#ifndef IMPLEMENT_VEC2F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2f_t +vtrunc2f (vec2f_t v) +{ + vec4f_t t = { v[0], v[1], 0, 0 }; + t = _mm_round_ps (t, _MM_FROUND_TRUNC); + return (vec2f_t) { t[0], t[1] }; +} + +#ifndef IMPLEMENT_VEC2F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2f_t +dot2f (vec2f_t a, vec2f_t b) +{ + vec2f_t c = a * b; + vec4f_t t = { c[0], c[1], 0, 0 }; + t = _mm_hadd_ps (t, t); + return (vec2f_t) { t[0], t[1] }; +} + +#ifndef IMPLEMENT_VEC2F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2f_t +cmulf (vec2f_t a, vec2f_t b) +{ + vec2f_t c1 = a * b[0]; + vec2f_t c2 = a * b[1]; + vec4f_t c14 ={ c1[0], c1[1], 0, 0 }; + vec4f_t c24 ={ c2[1], c2[0], 0, 0 }; + vec4f_t c = _mm_addsub_ps (c14, c24); + return (vec2f_t) { c[0], c[1] }; +} + +#ifndef IMPLEMENT_VEC2F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2f_t +normal2f (vec2f_t v) +{ + return v / vsqrt2f (dot2f (v, v)); +} + +#ifndef IMPLEMENT_VEC2F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2f_t +magnitude2f (vec2f_t v) +{ + return vsqrt2f (dot2f (v, v)); +} + +#endif//__QF_simd_vec2f_h diff --git a/include/QF/simd/vec4d.h b/include/QF/simd/vec4d.h index 058635dd7..3b87eb14a 100644 --- a/include/QF/simd/vec4d.h +++ b/include/QF/simd/vec4d.h @@ -33,10 +33,10 @@ #include "QF/simd/types.h" -GNU89INLINE inline vec4d_t vsqrtd (vec4d_t v) __attribute__((const)); -GNU89INLINE inline vec4d_t vceild (vec4d_t v) __attribute__((const)); -GNU89INLINE inline vec4d_t vfloord (vec4d_t v) __attribute__((const)); -GNU89INLINE inline vec4d_t vtruncd (vec4d_t v) __attribute__((const)); +GNU89INLINE inline vec4d_t vsqrt4d (vec4d_t v) __attribute__((const)); +GNU89INLINE inline vec4d_t vceil4d (vec4d_t v) __attribute__((const)); +GNU89INLINE inline vec4d_t vfloor4d (vec4d_t v) __attribute__((const)); +GNU89INLINE inline vec4d_t vtrunc4d (vec4d_t v) __attribute__((const)); /** 3D vector cross product. * * The w (4th) component can be any value on input, and is guaranteed to be 0 @@ -96,6 +96,8 @@ GNU89INLINE inline vec4d_t qrotd (vec4d_t a, vec4d_t b) __attribute__((const)); GNU89INLINE inline vec4d_t qconjd (vec4d_t q) __attribute__((const)); GNU89INLINE inline vec4d_t loadvec3d (const double v3[]) __attribute__((pure)); GNU89INLINE inline void storevec3d (double v3[3], vec4d_t v4); +GNU89INLINE inline vec4l_t loadvec3l (const long *v3) __attribute__((pure)); +GNU89INLINE inline void storevec3l (long *v3, vec4l_t v4); #ifndef IMPLEMENT_VEC4D_Funcs GNU89INLINE inline @@ -103,7 +105,7 @@ GNU89INLINE inline VISIBLE #endif vec4d_t -vsqrtd (vec4d_t v) +vsqrt4d (vec4d_t v) { return _mm256_sqrt_pd (v); } @@ -114,7 +116,7 @@ GNU89INLINE inline VISIBLE #endif vec4d_t -vceild (vec4d_t v) +vceil4d (vec4d_t v) { return _mm256_ceil_pd (v); } @@ -125,7 +127,7 @@ GNU89INLINE inline VISIBLE #endif vec4d_t -vfloord (vec4d_t v) +vfloor4d (vec4d_t v) { return _mm256_floor_pd (v); } @@ -136,7 +138,7 @@ GNU89INLINE inline VISIBLE #endif vec4d_t -vtruncd (vec4d_t v) +vtrunc4d (vec4d_t v) { return _mm256_round_pd (v, _MM_FROUND_TRUNC); } @@ -241,11 +243,11 @@ VISIBLE vec4d_t qrotd (vec4d_t a, vec4d_t b) { - vec4d_t ma = vsqrtd (dotd (a, a)); - vec4d_t mb = vsqrtd (dotd (b, b)); + vec4d_t ma = vsqrt4d (dotd (a, a)); + vec4d_t mb = vsqrt4d (dotd (b, b)); vec4d_t den = 2 * ma * mb; vec4d_t t = mb * a + ma * b; - vec4d_t mba_mab = vsqrtd (dotd (t, t)); + vec4d_t mba_mab = vsqrt4d (dotd (t, t)); vec4d_t q = crossd (a, b) / mba_mab; q[3] = (mba_mab / den)[0]; return q; @@ -293,6 +295,31 @@ storevec3d (double v3[3], vec4d_t v4) v3[2] = v4[2]; } +#ifndef IMPLEMENT_VEC4F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec4l_t +loadvec3l (const long *v3) +{ + vec4l_t v4 = { v3[0], v3[1], v3[2], 0 }; + return v4; +} + +#ifndef IMPLEMENT_VEC4F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +void +storevec3l (long *v3, vec4l_t v4) +{ + v3[0] = v4[0]; + v3[1] = v4[1]; + v3[2] = v4[2]; +} + #endif #endif//__QF_simd_vec4d_h diff --git a/include/QF/simd/vec4f.h b/include/QF/simd/vec4f.h index 6bb0ae4ec..9105e7952 100644 --- a/include/QF/simd/vec4f.h +++ b/include/QF/simd/vec4f.h @@ -33,11 +33,11 @@ #include "QF/simd/types.h" -GNU89INLINE inline vec4f_t vabsf (vec4f_t v) __attribute__((const)); -GNU89INLINE inline vec4f_t vsqrtf (vec4f_t v) __attribute__((const)); -GNU89INLINE inline vec4f_t vceilf (vec4f_t v) __attribute__((const)); -GNU89INLINE inline vec4f_t vfloorf (vec4f_t v) __attribute__((const)); -GNU89INLINE inline vec4f_t vtruncf (vec4f_t v) __attribute__((const)); +GNU89INLINE inline vec4f_t vabs4f (vec4f_t v) __attribute__((const)); +GNU89INLINE inline vec4f_t vsqrt4f (vec4f_t v) __attribute__((const)); +GNU89INLINE inline vec4f_t vceil4f (vec4f_t v) __attribute__((const)); +GNU89INLINE inline vec4f_t vfloor4f (vec4f_t v) __attribute__((const)); +GNU89INLINE inline vec4f_t vtrunc4f (vec4f_t v) __attribute__((const)); /** 3D vector cross product. * * The w (4th) component can be any value on input, and is guaranteed to be 0 @@ -99,6 +99,8 @@ GNU89INLINE inline void storevec3f (float *v3, vec4f_t v4); GNU89INLINE inline vec4f_t normalf (vec4f_t v) __attribute__((pure)); GNU89INLINE inline vec4f_t magnitudef (vec4f_t v) __attribute__((pure)); GNU89INLINE inline vec4f_t magnitude3f (vec4f_t v) __attribute__((pure)); +GNU89INLINE inline vec4i_t loadvec3i (const int *v3) __attribute__((pure)); +GNU89INLINE inline void storevec3i (int *v3, vec4i_t v4); #ifndef IMPLEMENT_VEC4F_Funcs GNU89INLINE inline @@ -106,7 +108,7 @@ GNU89INLINE inline VISIBLE #endif vec4f_t -vabsf (vec4f_t v) +vabs4f (vec4f_t v) { const uint32_t nan = ~0u >> 1; const vec4i_t abs = { nan, nan, nan, nan }; @@ -119,7 +121,7 @@ GNU89INLINE inline VISIBLE #endif vec4f_t -vsqrtf (vec4f_t v) +vsqrt4f (vec4f_t v) { #ifndef __SSE__ vec4f_t r = { sqrtf (v[0]), sqrtf (v[1]), sqrtf (v[2]), sqrtf (v[3]) }; @@ -135,7 +137,7 @@ GNU89INLINE inline VISIBLE #endif vec4f_t -vceilf (vec4f_t v) +vceil4f (vec4f_t v) { #ifndef __SSE4_1__ return (vec4f_t) { @@ -155,7 +157,7 @@ GNU89INLINE inline VISIBLE #endif vec4f_t -vfloorf (vec4f_t v) +vfloor4f (vec4f_t v) { #ifndef __SSE4_1__ return (vec4f_t) { @@ -175,7 +177,7 @@ GNU89INLINE inline VISIBLE #endif vec4f_t -vtruncf (vec4f_t v) +vtrunc4f (vec4f_t v) { #ifndef __SSE4_1__ return (vec4f_t) { @@ -296,11 +298,11 @@ VISIBLE vec4f_t qrotf (vec4f_t a, vec4f_t b) { - vec4f_t ma = vsqrtf (dotf (a, a)); - vec4f_t mb = vsqrtf (dotf (b, b)); + vec4f_t ma = vsqrt4f (dotf (a, a)); + vec4f_t mb = vsqrt4f (dotf (b, b)); vec4f_t den = 2 * ma * mb; vec4f_t t = mb * a + ma * b; - vec4f_t mba_mab = vsqrtf (dotf (t, t)); + vec4f_t mba_mab = vsqrt4f (dotf (t, t)); vec4f_t q = crossf (a, b) / mba_mab; q[3] = (mba_mab / den)[0]; return q; @@ -388,7 +390,7 @@ VISIBLE vec4f_t normalf (vec4f_t v) { - return v / vsqrtf (dotf (v, v)); + return v / vsqrt4f (dotf (v, v)); } #ifndef IMPLEMENT_VEC4F_Funcs @@ -399,7 +401,7 @@ VISIBLE vec4f_t magnitudef (vec4f_t v) { - return vsqrtf (dotf (v, v)); + return vsqrt4f (dotf (v, v)); } #ifndef IMPLEMENT_VEC4F_Funcs @@ -411,7 +413,7 @@ vec4f_t magnitude3f (vec4f_t v) { v[3] = 0; - return vsqrtf (dotf (v, v)); + return vsqrt4f (dotf (v, v)); } vec4f_t __attribute__((pure)) @@ -422,4 +424,29 @@ CircumSphere_vf (const vec4f_t *points, int num_points); vspheref_t SmallestEnclosingBall_vf (const vec4f_t *points, int num_points); +#ifndef IMPLEMENT_VEC4F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec4i_t +loadvec3i (const int *v3) +{ + vec4i_t v4 = { v3[0], v3[1], v3[2], 0 }; + return v4; +} + +#ifndef IMPLEMENT_VEC4F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +void +storevec3i (int *v3, vec4i_t v4) +{ + v3[0] = v4[0]; + v3[1] = v4[1]; + v3[2] = v4[2]; +} + #endif//__QF_simd_vec4f_h diff --git a/libs/util/cexpr-type.c b/libs/util/cexpr-type.c index 9ecba1804..b5260203e 100644 --- a/libs/util/cexpr-type.c +++ b/libs/util/cexpr-type.c @@ -425,7 +425,7 @@ vector_rem (const exprval_t *val1, const exprval_t *val2, exprval_t *result, vec4f_t a = *(vec4f_t *) val1->value; vec4f_t b = *(vec4f_t *) val2->value; __auto_type c = (vec4f_t *) result->value; - *c = a - b * vtruncf (a / b); + *c = a - b * vtrunc4f (a / b); } static void @@ -440,7 +440,7 @@ vector_mod (const exprval_t *val1, const exprval_t *val2, exprval_t *result, vec4f_t a = *(vec4f_t *) val1->value; vec4f_t b = *(vec4f_t *) val2->value; __auto_type c = (vec4f_t *) result->value; - *c = a - b * vfloorf (a / b); + *c = a - b * vfloor4f (a / b); } static void diff --git a/libs/util/simd.c b/libs/util/simd.c index f10c97acd..c6cedf222 100644 --- a/libs/util/simd.c +++ b/libs/util/simd.c @@ -32,11 +32,15 @@ #include +#define IMPLEMENT_VEC2F_Funcs +#define IMPLEMENT_VEC2D_Funcs #define IMPLEMENT_VEC4F_Funcs #define IMPLEMENT_VEC4D_Funcs #define IMPLEMENT_MAT4F_Funcs #include "QF/mathlib.h" +#include "QF/simd/vec2d.h" +#include "QF/simd/vec2f.h" #include "QF/simd/vec4d.h" #include "QF/simd/vec4f.h" #include "QF/simd/mat4f.h" diff --git a/libs/util/test/test-simd.c b/libs/util/test/test-simd.c index ae2fd6547..d1b4bf286 100644 --- a/libs/util/test/test-simd.c +++ b/libs/util/test/test-simd.c @@ -97,17 +97,17 @@ typedef struct { #ifdef __AVX2__ static vec4d_t tvtruncd (vec4d_t v, vec4d_t ignore) { - return vtruncd (v); + return vtrunc4d (v); } static vec4d_t tvceild (vec4d_t v, vec4d_t ignore) { - return vceild (v); + return vceil4d (v); } static vec4d_t tvfloord (vec4d_t v, vec4d_t ignore) { - return vfloord (v); + return vfloor4d (v); } static vec4d_t tqconjd (vec4d_t v, vec4d_t ignore) @@ -118,17 +118,17 @@ static vec4d_t tqconjd (vec4d_t v, vec4d_t ignore) static vec4f_t tvtruncf (vec4f_t v, vec4f_t ignore) { - return vtruncf (v); + return vtrunc4f (v); } static vec4f_t tvceilf (vec4f_t v, vec4f_t ignore) { - return vceilf (v); + return vceil4f (v); } static vec4f_t tvfloorf (vec4f_t v, vec4f_t ignore) { - return vfloorf (v); + return vfloor4f (v); } static vec4f_t tqconjf (vec4f_t v, vec4f_t ignore) @@ -138,12 +138,12 @@ static vec4f_t tqconjf (vec4f_t v, vec4f_t ignore) static vec4f_t tvabsf (vec4f_t v, vec4f_t ignore) { - return vabsf (v); + return vabs4f (v); } static vec4f_t tvsqrtf (vec4f_t v, vec4f_t ignore) { - return vsqrtf (v); + return vsqrt4f (v); } static vec4f_t tmagnitudef (vec4f_t v, vec4f_t ignore) diff --git a/tools/qfvis/source/flow.c b/tools/qfvis/source/flow.c index 27399eead..93ee0ec96 100644 --- a/tools/qfvis/source/flow.c +++ b/tools/qfvis/source/flow.c @@ -156,7 +156,7 @@ calc_plane (vec4f_t v1, vec4f_t v2, int flip, vec4f_t p, vec4f_t *plane) if (length[0] < ON_EPSILON) return 0; - *plane /= vsqrtf (length); + *plane /= vsqrt4f (length); (*plane)[3] = -dotf (p, *plane)[0]; return 1; } @@ -371,7 +371,7 @@ RecursiveClusterFlow (int clusternum, threaddata_t *thread, pstack_t *prevstack) // get plane of target_portal, point normal into the neighbor cluster backplane = -target_portal->plane; - vec4f_t diff = vabsf (pass_plane - backplane); + vec4f_t diff = vabs4f (pass_plane - backplane); vec4i_t cmp = diff > (vec4f_t) {0.001, 0.001, 0.001, 0.001}; if (!(cmp[0] || cmp[1] || cmp[2])) { // dist isn't interesting continue; // can't go out a coplanar face From 9aa8f18d73155f781aaf9907af6a8774a665e586 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 2 Jan 2022 01:06:22 +0900 Subject: [PATCH 005/360] [math] Split out Quat/Vector compare implementations This renames existing VectorCompCompare (and quaternion equivalent) to VectorCompCompareAll and makes VectorCompCompare produce a vector of results with optional negation (converting 0,1 to 0,-1 for compatibility with simd semantics). --- include/QF/math/quaternion.h | 11 +++++++++-- include/QF/math/vector.h | 10 ++++++++-- nq/source/sv_phys.c | 4 ++-- qw/source/sv_phys.c | 4 ++-- 4 files changed, 21 insertions(+), 8 deletions(-) diff --git a/include/QF/math/quaternion.h b/include/QF/math/quaternion.h index da39b7734..60245ad77 100644 --- a/include/QF/math/quaternion.h +++ b/include/QF/math/quaternion.h @@ -115,10 +115,17 @@ extern const vec_t *const quat_origin; (c)[2] = (a)[2] / (b)[2]; \ (c)[3] = (a)[3] / (b)[3]; \ } while (0) -#define QuatCompCompare(x, op, y) \ +#define QuatCompCompare(m, a, op, b, c) \ + do { \ + (c)[0] = m((a)[0] op (b)[0]); \ + (c)[1] = m((a)[1] op (b)[1]); \ + (c)[2] = m((a)[2] op (b)[2]); \ + (c)[3] = m((a)[3] op (b)[3]); \ + } while (0) +#define QuatCompCompareAll(x, op, y) \ (((x)[0] op (y)[0]) && ((x)[1] op (y)[1]) \ && ((x)[2] op (y)[2]) && ((x)[3] op (y)[3])) -#define QuatCompare(x, y) QuatCompCompare (x, ==, y) +#define QuatCompare(x, y) QuatCompCompareAll (x, ==, y) #define QuatCompMin(a, b, c) \ do { \ (c)[0] = min ((a)[0], (b)[0]); \ diff --git a/include/QF/math/vector.h b/include/QF/math/vector.h index 6189d002c..100a98bd0 100644 --- a/include/QF/math/vector.h +++ b/include/QF/math/vector.h @@ -131,9 +131,15 @@ extern const vec_t *const vec3_origin; (c)[1] = (a)[1] / (b)[1]; \ (c)[2] = (a)[2] / (b)[2]; \ } while (0) -#define VectorCompCompare(x, op, y) \ +#define VectorCompCompare(c, m, a, op, b) \ + do { \ + (c)[0] = m((a)[0] op (b)[0]); \ + (c)[1] = m((a)[1] op (b)[1]); \ + (c)[2] = m((a)[2] op (b)[2]); \ + } while (0) +#define VectorCompCompareAll(x, op, y) \ (((x)[0] op (y)[0]) && ((x)[1] op (y)[1]) && ((x)[2] op (y)[2])) -#define VectorCompare(x, y) VectorCompCompare (x, ==, y) +#define VectorCompare(x, y) VectorCompCompareAll (x, ==, y) #define VectorCompMin(a, b, c) \ do { \ (c)[0] = min ((a)[0], (b)[0]); \ diff --git a/nq/source/sv_phys.c b/nq/source/sv_phys.c index ffaf35ae1..e017039a6 100644 --- a/nq/source/sv_phys.c +++ b/nq/source/sv_phys.c @@ -484,8 +484,8 @@ SV_Push (edict_t *pusher, const vec3_t tmove, const vec3_t amove) // entity? c_absmin = SVvector (check, absmin); c_absmax = SVvector (check, absmax); - if (VectorCompCompare (c_absmin, >=, maxs) - || VectorCompCompare (c_absmax, <=, mins)) + if (VectorCompCompareAll (c_absmin, >=, maxs) + || VectorCompCompareAll (c_absmax, <=, mins)) continue; if (!SV_TestEntityPosition (check)) diff --git a/qw/source/sv_phys.c b/qw/source/sv_phys.c index 41ae45ccd..79047699e 100644 --- a/qw/source/sv_phys.c +++ b/qw/source/sv_phys.c @@ -487,8 +487,8 @@ SV_Push (edict_t *pusher, const vec3_t tmove, const vec3_t amove) // entity? c_absmin = SVvector (check, absmin); c_absmax = SVvector (check, absmax); - if (VectorCompCompare (c_absmin, >=, maxs) - || VectorCompCompare (c_absmax, <=, mins)) + if (VectorCompCompareAll (c_absmin, >=, maxs) + || VectorCompCompareAll (c_absmax, <=, mins)) continue; if (!SV_TestEntityPosition (check)) From 937f36384b8c42fc46c8b5a8e470b70c7d023cdb Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 2 Jan 2022 01:13:17 +0900 Subject: [PATCH 006/360] [cexpr] Use correct functions for double trunc/floor Found while sorting out the changes for the new 2d vectors. --- libs/util/cexpr-type.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/util/cexpr-type.c b/libs/util/cexpr-type.c index b5260203e..1efbb2f2a 100644 --- a/libs/util/cexpr-type.c +++ b/libs/util/cexpr-type.c @@ -350,7 +350,7 @@ double_rem (const exprval_t *val1, const exprval_t *val2, exprval_t *result, { double a = *(double *) val1->value; double b = *(double *) val2->value; - *(double *) result->value = a - b * truncf (a / b); + *(double *) result->value = a - b * trunc (a / b); } static void @@ -364,7 +364,7 @@ double_mod (const exprval_t *val1, const exprval_t *val2, exprval_t *result, // -5 mod -3 = -2 double a = *(double *) val1->value; double b = *(double *) val2->value; - *(double *) result->value = a - b * floorf (a / b); + *(double *) result->value = a - b * floor (a / b); } CASTOP (double, int) From 5fb28d7c38106a45894659b84cf6c34717066e17 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 2 Jan 2022 01:15:17 +0900 Subject: [PATCH 007/360] [math] Clean up vector component operations And add a unary op macro. Having VectorCompOp makes it easy to write macros that work for multiple data widths, which is why it and its users now use (dst, ...) instead of (..., dst) as in the past. I'll sort out the other macros later now that I know the compiler handily gives messages about the switched order (uninitialized vars etc). --- include/QF/math/vector.h | 50 +++++++++++++++----------------------- libs/models/trace.c | 22 ++++++++--------- libs/util/test/test-mat3.c | 6 ++--- libs/util/test/test-mat4.c | 6 ++--- 4 files changed, 37 insertions(+), 47 deletions(-) diff --git a/include/QF/math/vector.h b/include/QF/math/vector.h index 100a98bd0..f45893f50 100644 --- a/include/QF/math/vector.h +++ b/include/QF/math/vector.h @@ -37,25 +37,27 @@ extern const vec_t *const vec3_origin; +#define VectorCompUop(b, op, a) \ + do { \ + (b)[0] = op ((a)[0]); \ + (b)[1] = op ((a)[1]); \ + (b)[2] = op ((a)[2]); \ + } while (0) +#define VectorCompOp(c, a, op, b) \ + do { \ + (c)[0] = (a)[0] op (b)[0]; \ + (c)[1] = (a)[1] op (b)[1]; \ + (c)[2] = (a)[2] op (b)[2]; \ + } while (0) +#define VectorCompAdd(c,a,b) VectorCompOp (c, a, +, b) +#define VectorCompSub(c,a,b) VectorCompOp (c, a, -, b) +#define VectorCompMult(c,a,b) VectorCompOp (c, a, *, b) +#define VectorCompDiv(c,a,b) VectorCompOp (c, a, /, b) + #define DotProduct(a,b) ((a)[0] * (b)[0] + (a)[1] * (b)[1] + (a)[2] * (b)[2]) -#define VectorSubtract(a,b,c) \ - do { \ - (c)[0] = (a)[0] - (b)[0]; \ - (c)[1] = (a)[1] - (b)[1]; \ - (c)[2] = (a)[2] - (b)[2]; \ - } while (0) -#define VectorNegate(a,b) \ - do { \ - (b)[0] = -(a)[0]; \ - (b)[1] = -(a)[1]; \ - (b)[2] = -(a)[2]; \ - } while (0) -#define VectorAdd(a,b,c) \ - do { \ - (c)[0] = (a)[0] + (b)[0]; \ - (c)[1] = (a)[1] + (b)[1]; \ - (c)[2] = (a)[2] + (b)[2]; \ - } while (0) +#define VectorSubtract(a,b,c) VectorCompSub (c, a, b) +#define VectorNegate(a,b) VectorCompUop (b, -, a) +#define VectorAdd(a,b,c) VectorCompAdd (c, a, b) #define VectorCopy(a,b) \ do { \ (b)[0] = (a)[0]; \ @@ -119,18 +121,6 @@ extern const vec_t *const vec3_origin; (c)[1] = (b)[1] - (b)[0] * (a)[0]; \ (c)[0] = (b)[0]; \ } while (0) -#define VectorCompMult(a,b,c) \ - do { \ - (c)[0] = (a)[0] * (b)[0]; \ - (c)[1] = (a)[1] * (b)[1]; \ - (c)[2] = (a)[2] * (b)[2]; \ - } while (0) -#define VectorCompDiv(a,b,c) \ - do { \ - (c)[0] = (a)[0] / (b)[0]; \ - (c)[1] = (a)[1] / (b)[1]; \ - (c)[2] = (a)[2] / (b)[2]; \ - } while (0) #define VectorCompCompare(c, m, a, op, b) \ do { \ (c)[0] = m((a)[0] op (b)[0]); \ diff --git a/libs/models/trace.c b/libs/models/trace.c index 1fcecb47b..d65a06c9a 100644 --- a/libs/models/trace.c +++ b/libs/models/trace.c @@ -120,7 +120,7 @@ init_box (const trace_t *trace, clipbox_t *box, const vec3_t vel) //FIXME rotated box for (i = 0; i < 3; i++) u[i] = (vel[i] >= 0 ? 1 : -1); - VectorCompMult (u, trace->extents, p); + VectorCompMult (p, u, trace->extents); for (i = 0; i < 3; i++) { box->portals[i].planenum = i; box->portals[i].next[0] = 0; @@ -153,17 +153,17 @@ init_box (const trace_t *trace, clipbox_t *box, const vec3_t vel) box->edges[i].points[j][a] = s[k] * u[i] * box->edges[i].points[j - 1][b]; } - VectorCompMult (box->points[i].points[j - 1], trace->extents, - box->points[i].points[j - 1]); - VectorCompMult (box->edges[i].points[j - 1], trace->extents, - box->edges[i].points[j - 1]); + VectorCompMult (box->points[i].points[j - 1], + box->points[i].points[j - 1], trace->extents); + VectorCompMult (box->edges[i].points[j - 1], + box->edges[i].points[j - 1], trace->extents); VectorScale (box->edges[i].points[j - 1], 2, box->edges[i].points[j - 1]); } - VectorCompMult (box->points[i].points[3], trace->extents, - box->points[i].points[3]); - VectorCompMult (box->edges[i].points[3], trace->extents, - box->edges[i].points[3]); + VectorCompMult (box->points[i].points[3], + box->points[i].points[3], trace->extents); + VectorCompMult (box->edges[i].points[3], + box->edges[i].points[3], trace->extents); VectorScale (box->edges[i].points[3], 2, box->edges[i].points[3]); } @@ -566,8 +566,8 @@ portal_intersect (trace_t *trace, clipport_t *portal, plane_t *plane, vec3_t p1, p2, imp, dist; vec_t t1, t2, frac; - VectorCompMult (trace->extents, verts[i][0], p1); - VectorCompMult (trace->extents, verts[i][1], p2); + VectorCompMult (p1, trace->extents, verts[i][0]); + VectorCompMult (p2, trace->extents, verts[i][1]); t1 = PlaneDiff (p1, plane) + o_n; t2 = PlaneDiff (p2, plane) + o_n; // if both ends of the box edge are on the same side (or touching) the diff --git a/libs/util/test/test-mat3.c b/libs/util/test/test-mat3.c index 903c4de9f..9134fb9c2 100644 --- a/libs/util/test/test-mat3.c +++ b/libs/util/test/test-mat3.c @@ -99,7 +99,7 @@ test_transform (const vec3_t angles, const vec3_t scale) VectorCopy (v, x); AngleQuat (angles, rotation); - VectorCompMult (scale, x, x); + VectorCompMult (x, scale, x); QuatMultVec (rotation, x, x); Mat3Init (rotation, scale, mat); @@ -132,7 +132,7 @@ test_transform2 (const vec3_t angles, const vec3_t scale) VectorCopy (v, x); AngleQuat (angles, rotation); - VectorCompMult (scale, x, x); + VectorCompMult (x, scale, x); QuatMultVec (rotation, x, x); Mat3Init (rotation, scale, mat); @@ -141,7 +141,7 @@ test_transform2 (const vec3_t angles, const vec3_t scale) VectorCopy (v, y); QuatMultVec (rot, y, y); VectorShear (sh, y, y); - VectorCompMult (sc, y, y);//scale + VectorCompMult (y, sc, y);//scale for (i = 0; i < 3; i++) if (!compare (x[i], y[i])) diff --git a/libs/util/test/test-mat4.c b/libs/util/test/test-mat4.c index 1bd7afcc9..cd30c0990 100644 --- a/libs/util/test/test-mat4.c +++ b/libs/util/test/test-mat4.c @@ -114,7 +114,7 @@ test_transform (const vec3_t angles, const vec3_t scale, VectorCopy (v, x); AngleQuat (angles, rotation); - VectorCompMult (scale, x, x); + VectorCompMult (x, scale, x); QuatMultVec (rotation, x, x); VectorAdd (x, translation, x); @@ -148,7 +148,7 @@ test_transform2 (const vec3_t angles, const vec3_t scale, VectorCopy (v, x); AngleQuat (angles, rotation); - VectorCompMult (scale, x, x); + VectorCompMult (x, scale, x); QuatMultVec (rotation, x, x); VectorAdd (translation, x, x); @@ -158,7 +158,7 @@ test_transform2 (const vec3_t angles, const vec3_t scale, VectorCopy (v, y); QuatMultVec (rot, y, y); VectorShear (sh, y, y); - VectorCompMult (sc, y, y);//scale + VectorCompMult (y, sc, y);//scale VectorAdd (tr, y, y); for (i = 0; i < 3; i++) From f56fd6ffb6bac7af3cf68c467b6efd3ac85d9068 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 2 Jan 2022 11:42:27 +0900 Subject: [PATCH 008/360] [qfcc] Preserve requested alignment if larger build_struct was unconditionally setting the type's alignment. This was not a problem before because no types were requesting alignments larger than those requested by their members (for structs). However, with the upcoming new instruction set, quaternions need to be 4-word aligned. --- tools/qfcc/source/struct.c | 4 +++- tools/qfcc/source/type.c | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/tools/qfcc/source/struct.c b/tools/qfcc/source/struct.c index ef9bd7389..4bd82130c 100644 --- a/tools/qfcc/source/struct.c +++ b/tools/qfcc/source/struct.c @@ -171,7 +171,9 @@ build_struct (int su, symbol_t *tag, symtab_t *symtab, type_t *type) if (!type) sym->type = find_type (sym->type); // checks the tag, not the symtab sym->type->t.symtab = symtab; - sym->type->alignment = alignment; + if (alignment > sym->type->alignment) { + sym->type->alignment = alignment; + } if (!type && sym->type->type_def->external) //FIXME should not be necessary sym->type->type_def = qfo_encode_type (sym->type, pr.type_data); return sym; diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index 3c6a4a683..bccf431b7 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -74,7 +74,7 @@ type_t type_function = { ev_func, "function", 1, ty_basic, {{&type_void}} }; type_t type_pointer = { ev_pointer, "pointer", 1, ty_basic, {{&type_void}} }; -type_t type_quaternion = { ev_quat, "quaternion", 1 }; +type_t type_quaternion = { ev_quat, "quaternion", 4 }; type_t type_integer = { ev_integer, "int", 1 }; type_t type_uinteger = { ev_uinteger, "uint", 1 }; type_t type_short = { ev_short, "short", 1 }; From 0e1964bf74987f882260d4b9ed44007e4e484971 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 2 Jan 2022 16:02:57 +0900 Subject: [PATCH 009/360] [simd] Split out the ivec implementations And add any/all/none functions. --- include/QF/simd/vec2i.h | 90 +++++++++++++++++++++++++++++ include/QF/simd/vec4f.h | 27 --------- include/QF/simd/vec4i.h | 123 ++++++++++++++++++++++++++++++++++++++++ libs/util/simd.c | 4 ++ 4 files changed, 217 insertions(+), 27 deletions(-) create mode 100644 include/QF/simd/vec2i.h create mode 100644 include/QF/simd/vec4i.h diff --git a/include/QF/simd/vec2i.h b/include/QF/simd/vec2i.h new file mode 100644 index 000000000..694d5fa7b --- /dev/null +++ b/include/QF/simd/vec2i.h @@ -0,0 +1,90 @@ +/* + QF/simd/vec2i.h + + Vector functions for vec2i_t (ie, int) + + Copyright (C) 2022 Bill Currie + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + +*/ + +#ifndef __QF_simd_vec2i_h +#define __QF_simd_vec2i_h + +#include +#include + +#include "QF/simd/types.h" + +GNU89INLINE inline vec2i_t vabs2i (vec2i_t v) __attribute__((const)); +GNU89INLINE inline int any2i (vec2i_t v) __attribute__((const)); +GNU89INLINE inline int all2i (vec2i_t v) __attribute__((const)); +GNU89INLINE inline int none2i (vec2i_t v) __attribute__((const)); + +#ifndef IMPLEMENT_VEC2I_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec2i_t +vabs2i (vec2i_t v) +{ + const uint32_t nan = ~0u >> 1; + const vec2i_t abs = { nan, nan }; + return (vec2i_t) ((vec2i_t) v & abs); +} + +#ifndef IMPLEMENT_VEC2I_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +int +any2i (vec2i_t v) +{ + vec2i_t t = _m_pcmpeqd (v, (vec2i_t) {0, 0}); + return _mm_hadd_pi32 (t, t)[0] > -2; +} + +#ifndef IMPLEMENT_VEC2I_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +int +all2i (vec2i_t v) +{ + vec2i_t t = _m_pcmpeqd (v, (vec2i_t) {0, 0}); + return _mm_hadd_pi32 (t, t)[0] == 0; +} + +#ifndef IMPLEMENT_VEC2I_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +int +none2i (vec2i_t v) +{ + vec2i_t t = _m_pcmpeqd (v, (vec2i_t) {0, 0}); + return _mm_hadd_pi32 (t, t)[0] == -2; +} + +#endif//__QF_simd_vec2i_h diff --git a/include/QF/simd/vec4f.h b/include/QF/simd/vec4f.h index 9105e7952..7b7c8429d 100644 --- a/include/QF/simd/vec4f.h +++ b/include/QF/simd/vec4f.h @@ -99,8 +99,6 @@ GNU89INLINE inline void storevec3f (float *v3, vec4f_t v4); GNU89INLINE inline vec4f_t normalf (vec4f_t v) __attribute__((pure)); GNU89INLINE inline vec4f_t magnitudef (vec4f_t v) __attribute__((pure)); GNU89INLINE inline vec4f_t magnitude3f (vec4f_t v) __attribute__((pure)); -GNU89INLINE inline vec4i_t loadvec3i (const int *v3) __attribute__((pure)); -GNU89INLINE inline void storevec3i (int *v3, vec4i_t v4); #ifndef IMPLEMENT_VEC4F_Funcs GNU89INLINE inline @@ -424,29 +422,4 @@ CircumSphere_vf (const vec4f_t *points, int num_points); vspheref_t SmallestEnclosingBall_vf (const vec4f_t *points, int num_points); -#ifndef IMPLEMENT_VEC4F_Funcs -GNU89INLINE inline -#else -VISIBLE -#endif -vec4i_t -loadvec3i (const int *v3) -{ - vec4i_t v4 = { v3[0], v3[1], v3[2], 0 }; - return v4; -} - -#ifndef IMPLEMENT_VEC4F_Funcs -GNU89INLINE inline -#else -VISIBLE -#endif -void -storevec3i (int *v3, vec4i_t v4) -{ - v3[0] = v4[0]; - v3[1] = v4[1]; - v3[2] = v4[2]; -} - #endif//__QF_simd_vec4f_h diff --git a/include/QF/simd/vec4i.h b/include/QF/simd/vec4i.h new file mode 100644 index 000000000..6320cd83a --- /dev/null +++ b/include/QF/simd/vec4i.h @@ -0,0 +1,123 @@ +/* + QF/simd/vec4i.h + + Vector functions for vec4i_t (ie, int) + + Copyright (C) 2022 Bill Currie + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + +*/ + +#ifndef __QF_simd_vec4i_h +#define __QF_simd_vec4i_h + +#include +#include + +#include "QF/simd/types.h" + +GNU89INLINE inline vec4i_t vabs4i (vec4i_t v) __attribute__((const)); +GNU89INLINE inline int any4i (vec4i_t v) __attribute__((const)); +GNU89INLINE inline int all4i (vec4i_t v) __attribute__((const)); +GNU89INLINE inline int none4i (vec4i_t v) __attribute__((const)); +GNU89INLINE inline vec4i_t loadvec3i (const int *v3) __attribute__((pure)); +GNU89INLINE inline void storevec3i (int *v3, vec4i_t v4); + +#ifndef IMPLEMENT_VEC4F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec4i_t +vabs4i (vec4i_t v) +{ + const uint32_t nan = ~0u >> 1; + const vec4i_t abs = { nan, nan, nan, nan }; + return (vec4i_t) ((vec4i_t) v & abs); +} + +#ifndef IMPLEMENT_VEC2I_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +int +any4i (vec4i_t v) +{ + return !__builtin_ia32_ptestz128 ((__v2di)v, (__v2di)v); + /*vec4i_t t = (v != (vec4i_t) {}); + t = __builtin_ia32_phaddd128 (t, t); + return __builtin_ia32_phaddd128 (t, t)[0] != 0;*/ +} + +#ifndef IMPLEMENT_VEC2I_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +int +all4i (vec4i_t v) +{ + vec4i_t t = (v == (vec4i_t) {}); + return __builtin_ia32_ptestz128 ((__v2di)t, (__v2di)t); + /*t = __builtin_ia32_phaddd128 (t, t); + return __builtin_ia32_phaddd128 (t, t)[0] == 0;*/ +} + +#ifndef IMPLEMENT_VEC2I_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +int +none4i (vec4i_t v) +{ + return __builtin_ia32_ptestz128 ((__v2di)v, (__v2di)v); + /*vec4i_t t = (v != (vec4i_t) {}); + t = __builtin_ia32_phaddd128 (t, t); + return __builtin_ia32_phaddd128 (t, t)[0] == 0;*/ +} + +#ifndef IMPLEMENT_VEC4F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec4i_t +loadvec3i (const int *v3) +{ + vec4i_t v4 = { v3[0], v3[1], v3[2], 0 }; + return v4; +} + +#ifndef IMPLEMENT_VEC4F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +void +storevec3i (int *v3, vec4i_t v4) +{ + v3[0] = v4[0]; + v3[1] = v4[1]; + v3[2] = v4[2]; +} + +#endif//__QF_simd_vec4i_h diff --git a/libs/util/simd.c b/libs/util/simd.c index c6cedf222..352a4169a 100644 --- a/libs/util/simd.c +++ b/libs/util/simd.c @@ -34,15 +34,19 @@ #define IMPLEMENT_VEC2F_Funcs #define IMPLEMENT_VEC2D_Funcs +#define IMPLEMENT_VEC2I_Funcs #define IMPLEMENT_VEC4F_Funcs #define IMPLEMENT_VEC4D_Funcs +#define IMPLEMENT_VEC4I_Funcs #define IMPLEMENT_MAT4F_Funcs #include "QF/mathlib.h" #include "QF/simd/vec2d.h" #include "QF/simd/vec2f.h" +#include "QF/simd/vec2i.h" #include "QF/simd/vec4d.h" #include "QF/simd/vec4f.h" +#include "QF/simd/vec4i.h" #include "QF/simd/mat4f.h" #include "QF/set.h" #include "QF/sys.h" From 63442895fcdfba70fd7a5107f4bcbf26192b6bfc Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 2 Jan 2022 16:10:37 +0900 Subject: [PATCH 010/360] [simd] Add the new headers to dist --- include/QF/Makemodule.am | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/include/QF/Makemodule.am b/include/QF/Makemodule.am index ff47836db..77f56e29b 100644 --- a/include/QF/Makemodule.am +++ b/include/QF/Makemodule.am @@ -145,8 +145,12 @@ include_qf_scene = \ include_qf_simd = \ include/QF/simd/mat4f.h \ include/QF/simd/types.h \ + include/QF/simd/vec2d.h \ + include/QF/simd/vec2f.h \ + include/QF/simd/vec2i.h \ include/QF/simd/vec4d.h \ - include/QF/simd/vec4f.h + include/QF/simd/vec4f.h \ + include/QF/simd/vec4i.h include_qf_ui = \ include/QF/ui/inputline.h \ From c42043ced408e3861a7ccf68abe493d2fad72d36 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 2 Jan 2022 17:48:43 +0900 Subject: [PATCH 011/360] [gamecode] Add types needed for new instruction set In particular, the various 2d and 4d vector types, and 64-bit types. Also, some aliases to make instruction implementation macros workable. --- include/QF/pr_comp.h | 26 ++++++++++++++++++++++++-- 1 file changed, 24 insertions(+), 2 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index 5d5efe942..1303fb2c5 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -23,13 +23,35 @@ #include "QF/qtypes.h" +typedef double pr_double_t; +typedef float pr_float_t; typedef int16_t pr_short_t; typedef uint16_t pr_ushort_t; typedef int32_t pr_int_t; typedef uint32_t pr_uint_t; +typedef int64_t pr_long_t; +typedef uint64_t pr_ulong_t; typedef pr_uint_t func_t; -typedef pr_int_t string_t; -typedef pr_uint_t pointer_t; +typedef pr_int_t pr_string_t; +typedef pr_string_t string_t;//FIXME +typedef pr_uint_t pr_pointer_t; +typedef pr_pointer_t pointer_t;//FIXME + +#define PR_VEC_TYPE(t,n,s) \ + typedef t n __attribute__ ((vector_size (s*sizeof (t)))) + +PR_VEC_TYPE (pr_int_t, pr_ivec2_t, 2); +PR_VEC_TYPE (pr_int_t, pr_ivec4_t, 4); +PR_VEC_TYPE (pr_uint_t, pr_uivec2_t, 2); +PR_VEC_TYPE (pr_uint_t, pr_uivec4_t, 4); +PR_VEC_TYPE (float, pr_vec2_t, 2); +PR_VEC_TYPE (float, pr_vec4_t, 4); +PR_VEC_TYPE (pr_long_t, pr_lvec2_t, 2); +PR_VEC_TYPE (pr_long_t, pr_lvec4_t, 4); +PR_VEC_TYPE (pr_ulong_t, pr_ulvec2_t, 2); +PR_VEC_TYPE (pr_ulong_t, pr_ulvec4_t, 4); +PR_VEC_TYPE (double, pr_dvec2_t, 2); +PR_VEC_TYPE (double, pr_dvec4_t, 4); typedef enum { ev_void, From ba5f6d97c680b8e40f86f4b6f1bd371c9147e110 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 2 Jan 2022 19:02:48 +0900 Subject: [PATCH 012/360] [gamecode] Remove the right_associative field It has been useless pretty much since I switched to using bison for the parser. --- include/QF/pr_comp.h | 1 - libs/gamecode/pr_opcode.c | 585 +++++++++++++++++++------------------- 2 files changed, 293 insertions(+), 293 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index 1303fb2c5..971584070 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -427,7 +427,6 @@ typedef enum { typedef struct opcode_s { const char *name; const char *opname; - qboolean right_associative; etype_t type_a, type_b, type_c; unsigned int min_version; const char *fmt; diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index 62239c561..955cc0796 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -96,1412 +96,1413 @@ VISIBLE const char * const pr_type_name[ev_type_count] = { // x place holder for P (padding) // 0-7 parameter index (for P) VISIBLE const opcode_t pr_opcodes[] = { - [OP_DONE] = {"", "done", false, // OP_DONE is actually the same as - ev_entity, ev_field, ev_void, // OP_RETURN, the types are bogus + // OP_DONE is actually the same as OP_RETURN, the types are bogus + [OP_DONE] = {"", "done", + ev_entity, ev_field, ev_void, PROG_ID_VERSION, "%Va", }, - [OP_MUL_D] = {"*", "mul.d", false, + [OP_MUL_D] = {"*", "mul.d", ev_double, ev_double, ev_double, PROG_VERSION, }, - [OP_MUL_F] = {"*", "mul.f", false, + [OP_MUL_F] = {"*", "mul.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_MUL_V] = {"*", "mul.v", false, + [OP_MUL_V] = {"*", "mul.v", ev_vector, ev_vector, ev_float, PROG_ID_VERSION, }, - [OP_MUL_FV] = {"*", "mul.fv", false, + [OP_MUL_FV] = {"*", "mul.fv", ev_float, ev_vector, ev_vector, PROG_ID_VERSION, }, - [OP_MUL_VF] = {"*", "mul.vf", false, + [OP_MUL_VF] = {"*", "mul.vf", ev_vector, ev_float, ev_vector, PROG_ID_VERSION, }, - [OP_MUL_DV] = {"*", "mul.dv", false, + [OP_MUL_DV] = {"*", "mul.dv", ev_double, ev_vector, ev_vector, PROG_ID_VERSION, }, - [OP_MUL_VD] = {"*", "mul.vd", false, + [OP_MUL_VD] = {"*", "mul.vd", ev_vector, ev_double, ev_vector, PROG_ID_VERSION, }, - [OP_MUL_Q] = {"*", "mul.q", false, + [OP_MUL_Q] = {"*", "mul.q", ev_quat, ev_quat, ev_quat, PROG_VERSION, }, - [OP_MUL_FQ] = {"*", "mul.fq", false, + [OP_MUL_FQ] = {"*", "mul.fq", ev_float, ev_quat, ev_quat, PROG_VERSION, }, - [OP_MUL_QF] = {"*", "mul.qf", false, + [OP_MUL_QF] = {"*", "mul.qf", ev_quat, ev_float, ev_quat, PROG_VERSION, }, - [OP_MUL_DQ] = {"*", "mul.dq", false, + [OP_MUL_DQ] = {"*", "mul.dq", ev_double, ev_quat, ev_quat, PROG_VERSION, }, - [OP_MUL_QD] = {"*", "mul.qd", false, + [OP_MUL_QD] = {"*", "mul.qd", ev_quat, ev_double, ev_quat, PROG_VERSION, }, - [OP_MUL_QV] = {"*", "mul.qv", false, + [OP_MUL_QV] = {"*", "mul.qv", ev_quat, ev_vector, ev_vector, PROG_VERSION, }, - [OP_CONJ_Q] = {"~", "conj.q", false, + [OP_CONJ_Q] = {"~", "conj.q", ev_quat, ev_invalid, ev_quat, PROG_VERSION, "%Ga, %gc", }, - [OP_DIV_F] = {"/", "div.f", false, + [OP_DIV_F] = {"/", "div.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_DIV_D] = {"/", "div.d", false, + [OP_DIV_D] = {"/", "div.d", ev_double, ev_double, ev_double, PROG_VERSION, }, - [OP_REM_D] = {"%", "rem.d", false, + [OP_REM_D] = {"%", "rem.d", ev_double, ev_double, ev_double, PROG_VERSION, }, - [OP_MOD_D] = {"%%", "mod.d", false, + [OP_MOD_D] = {"%%", "mod.d", ev_double, ev_double, ev_double, PROG_VERSION, }, - [OP_ADD_D] = {"+", "add.d", false, + [OP_ADD_D] = {"+", "add.d", ev_double, ev_double, ev_double, PROG_VERSION, }, - [OP_ADD_F] = {"+", "add.f", false, + [OP_ADD_F] = {"+", "add.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_ADD_V] = {"+", "add.v", false, + [OP_ADD_V] = {"+", "add.v", ev_vector, ev_vector, ev_vector, PROG_ID_VERSION, }, - [OP_ADD_Q] = {"+", "add.q", false, + [OP_ADD_Q] = {"+", "add.q", ev_quat, ev_quat, ev_quat, PROG_VERSION, }, - [OP_ADD_S] = {"+", "add.s", false, + [OP_ADD_S] = {"+", "add.s", ev_string, ev_string, ev_string, PROG_VERSION, }, - [OP_SUB_D] = {"-", "sub.d", false, + [OP_SUB_D] = {"-", "sub.d", ev_double, ev_double, ev_double, PROG_VERSION, }, - [OP_SUB_F] = {"-", "sub.f", false, + [OP_SUB_F] = {"-", "sub.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_SUB_V] = {"-", "sub.v", false, + [OP_SUB_V] = {"-", "sub.v", ev_vector, ev_vector, ev_vector, PROG_ID_VERSION, }, - [OP_SUB_Q] = {"-", "sub.q", false, + [OP_SUB_Q] = {"-", "sub.q", ev_quat, ev_quat, ev_quat, PROG_VERSION, }, - [OP_EQ_D] = {"==", "eq.d", false, + [OP_EQ_D] = {"==", "eq.d", ev_double, ev_double, ev_integer, PROG_VERSION, }, - [OP_EQ_F] = {"==", "eq.f", false, + [OP_EQ_F] = {"==", "eq.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_EQ_V] = {"==", "eq.v", false, + [OP_EQ_V] = {"==", "eq.v", ev_vector, ev_vector, ev_integer, PROG_ID_VERSION, }, - [OP_EQ_Q] = {"==", "eq.q", false, + [OP_EQ_Q] = {"==", "eq.q", ev_quat, ev_quat, ev_integer, PROG_VERSION, }, - [OP_EQ_S] = {"==", "eq.s", false, + [OP_EQ_S] = {"==", "eq.s", ev_string, ev_string, ev_integer, PROG_ID_VERSION, }, - [OP_EQ_E] = {"==", "eq.e", false, + [OP_EQ_E] = {"==", "eq.e", ev_entity, ev_entity, ev_integer, PROG_ID_VERSION, }, - [OP_EQ_FN] = {"==", "eq.fn", false, + [OP_EQ_FN] = {"==", "eq.fn", ev_func, ev_func, ev_integer, PROG_ID_VERSION, }, - [OP_NE_D] = {"!=", "ne.d", false, + [OP_NE_D] = {"!=", "ne.d", ev_double, ev_double, ev_integer, PROG_VERSION, }, - [OP_NE_F] = {"!=", "ne.f", false, + [OP_NE_F] = {"!=", "ne.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_NE_V] = {"!=", "ne.v", false, + [OP_NE_V] = {"!=", "ne.v", ev_vector, ev_vector, ev_integer, PROG_ID_VERSION, }, - [OP_NE_Q] = {"!=", "ne.q", false, + [OP_NE_Q] = {"!=", "ne.q", ev_quat, ev_quat, ev_integer, PROG_VERSION, }, - [OP_NE_S] = {"!=", "ne.s", false, + [OP_NE_S] = {"!=", "ne.s", ev_string, ev_string, ev_integer, PROG_ID_VERSION, }, - [OP_NE_E] = {"!=", "ne.e", false, + [OP_NE_E] = {"!=", "ne.e", ev_entity, ev_entity, ev_integer, PROG_ID_VERSION, }, - [OP_NE_FN] = {"!=", "ne.fn", false, + [OP_NE_FN] = {"!=", "ne.fn", ev_func, ev_func, ev_integer, PROG_ID_VERSION, }, - [OP_LE_D] = {"<=", "le.d", false, + [OP_LE_D] = {"<=", "le.d", ev_double, ev_double, ev_integer, PROG_VERSION, }, - [OP_LE_F] = {"<=", "le.f", false, + [OP_LE_F] = {"<=", "le.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_GE_D] = {">=", "ge.d", false, + [OP_GE_D] = {">=", "ge.d", ev_double, ev_double, ev_integer, PROG_VERSION, }, - [OP_GE_F] = {">=", "ge.f", false, + [OP_GE_F] = {">=", "ge.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_LE_S] = {"<=", "le.s", false, + [OP_LE_S] = {"<=", "le.s", ev_string, ev_string, ev_integer, PROG_VERSION, }, - [OP_GE_S] = {">=", "ge.s", false, + [OP_GE_S] = {">=", "ge.s", ev_string, ev_string, ev_integer, PROG_VERSION, }, - [OP_LT_D] = {"<", "lt.d", false, + [OP_LT_D] = {"<", "lt.d", ev_double, ev_double, ev_integer, PROG_VERSION, }, - [OP_LT_F] = {"<", "lt.f", false, + [OP_LT_F] = {"<", "lt.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_GT_D] = {">", "gt.d", false, + [OP_GT_D] = {">", "gt.d", ev_double, ev_double, ev_integer, PROG_VERSION, }, - [OP_GT_F] = {">", "gt.f", false, + [OP_GT_F] = {">", "gt.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_LT_S] = {"<", "lt.s", false, + [OP_LT_S] = {"<", "lt.s", ev_string, ev_string, ev_integer, PROG_VERSION, }, - [OP_GT_S] = {">", "gt.s", false, + [OP_GT_S] = {">", "gt.s", ev_string, ev_string, ev_integer, PROG_VERSION, }, - [OP_LOAD_F] = {".", "load.f", false, + [OP_LOAD_F] = {".", "load.f", ev_entity, ev_field, ev_float, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc",//FIXME %E more flexible? }, - [OP_LOAD_D] = {".", "load.d", false, + [OP_LOAD_D] = {".", "load.d", ev_entity, ev_field, ev_double, PROG_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_V] = {".", "load.v", false, + [OP_LOAD_V] = {".", "load.v", ev_entity, ev_field, ev_vector, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_Q] = {".", "load.q", false, + [OP_LOAD_Q] = {".", "load.q", ev_entity, ev_field, ev_quat, PROG_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_S] = {".", "load.s", false, + [OP_LOAD_S] = {".", "load.s", ev_entity, ev_field, ev_string, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_ENT] = {".", "load.ent", false, + [OP_LOAD_ENT] = {".", "load.ent", ev_entity, ev_field, ev_entity, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_FLD] = {".", "load.fld", false, + [OP_LOAD_FLD] = {".", "load.fld", ev_entity, ev_field, ev_field, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_FN] = {".", "load.fn", false, + [OP_LOAD_FN] = {".", "load.fn", ev_entity, ev_field, ev_func, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_I] = {".", "load.i", false, + [OP_LOAD_I] = {".", "load.i", ev_entity, ev_field, ev_integer, PROG_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_P] = {".", "load.p", false, + [OP_LOAD_P] = {".", "load.p", ev_entity, ev_field, ev_pointer, PROG_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOADB_D] = {".", "loadb.d", false, + [OP_LOADB_D] = {".", "loadb.d", ev_pointer, ev_integer, ev_double, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_F] = {".", "loadb.f", false, + [OP_LOADB_F] = {".", "loadb.f", ev_pointer, ev_integer, ev_float, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_V] = {".", "loadb.v", false, + [OP_LOADB_V] = {".", "loadb.v", ev_pointer, ev_integer, ev_vector, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_Q] = {".", "loadb.q", false, + [OP_LOADB_Q] = {".", "loadb.q", ev_pointer, ev_integer, ev_quat, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_S] = {".", "loadb.s", false, + [OP_LOADB_S] = {".", "loadb.s", ev_pointer, ev_integer, ev_string, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_ENT] = {".", "loadb.ent", false, + [OP_LOADB_ENT] = {".", "loadb.ent", ev_pointer, ev_integer, ev_entity, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_FLD] = {".", "loadb.fld", false, + [OP_LOADB_FLD] = {".", "loadb.fld", ev_pointer, ev_integer, ev_field, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_FN] = {".", "loadb.fn", false, + [OP_LOADB_FN] = {".", "loadb.fn", ev_pointer, ev_integer, ev_func, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_I] = {".", "loadb.i", false, + [OP_LOADB_I] = {".", "loadb.i", ev_pointer, ev_integer, ev_integer, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_P] = {".", "loadb.p", false, + [OP_LOADB_P] = {".", "loadb.p", ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADBI_D] = {".", "loadbi.d", false, + [OP_LOADBI_D] = {".", "loadbi.d", ev_pointer, ev_short, ev_double, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_F] = {".", "loadbi.f", false, + [OP_LOADBI_F] = {".", "loadbi.f", ev_pointer, ev_short, ev_float, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_V] = {".", "loadbi.v", false, + [OP_LOADBI_V] = {".", "loadbi.v", ev_pointer, ev_short, ev_vector, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_Q] = {".", "loadbi.q", false, + [OP_LOADBI_Q] = {".", "loadbi.q", ev_pointer, ev_short, ev_quat, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_S] = {".", "loadbi.s", false, + [OP_LOADBI_S] = {".", "loadbi.s", ev_pointer, ev_short, ev_string, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_ENT] = {".", "loadbi.ent", false, + [OP_LOADBI_ENT] = {".", "loadbi.ent", ev_pointer, ev_short, ev_entity, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_FLD] = {".", "loadbi.fld", false, + [OP_LOADBI_FLD] = {".", "loadbi.fld", ev_pointer, ev_short, ev_field, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_FN] = {".", "loadbi.fn", false, + [OP_LOADBI_FN] = {".", "loadbi.fn", ev_pointer, ev_short, ev_func, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_I] = {".", "loadbi.i", false, + [OP_LOADBI_I] = {".", "loadbi.i", ev_pointer, ev_short, ev_integer, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_P] = {".", "loadbi.p", false, + [OP_LOADBI_P] = {".", "loadbi.p", ev_pointer, ev_short, ev_pointer, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_ADDRESS] = {"&", "address", false, + [OP_ADDRESS] = {"&", "address", ev_entity, ev_field, ev_pointer, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_ADDRESS_VOID] = {"&", "address", false, + [OP_ADDRESS_VOID] = {"&", "address", ev_void, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_D] = {"&", "address.d", false, + [OP_ADDRESS_D] = {"&", "address.d", ev_double, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_F] = {"&", "address.f", false, + [OP_ADDRESS_F] = {"&", "address.f", ev_float, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_V] = {"&", "address.v", false, + [OP_ADDRESS_V] = {"&", "address.v", ev_vector, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_Q] = {"&", "address.q", false, + [OP_ADDRESS_Q] = {"&", "address.q", ev_quat, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_S] = {"&", "address.s", false, + [OP_ADDRESS_S] = {"&", "address.s", ev_string, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_ENT] = {"&", "address.ent", false, + [OP_ADDRESS_ENT] = {"&", "address.ent", ev_entity, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_FLD] = {"&", "address.fld", false, + [OP_ADDRESS_FLD] = {"&", "address.fld", ev_field, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_FN] = {"&", "address.fn", false, + [OP_ADDRESS_FN] = {"&", "address.fn", ev_func, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_I] = {"&", "address.i", false, + [OP_ADDRESS_I] = {"&", "address.i", ev_integer, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_P] = {"&", "address.p", false, + [OP_ADDRESS_P] = {"&", "address.p", ev_pointer, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_LEA] = {"&", "lea", false, + [OP_LEA] = {"&", "lea", ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "(%Ga + %Gb), %gc", }, - [OP_LEAI] = {"&", "leai", false, + [OP_LEAI] = {"&", "leai", ev_pointer, ev_short, ev_pointer, PROG_VERSION, "(%Ga + %sb), %gc", }, - [OP_CONV_IF] = {"", "conv.if", false, + [OP_CONV_IF] = {"", "conv.if", ev_integer, ev_invalid, ev_float, PROG_VERSION, "%Ga, %gc", }, - [OP_CONV_FI] = {"", "conv.fi", false, + [OP_CONV_FI] = {"", "conv.fi", ev_float, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_CONV_ID] = {"", "conv.id", false, + [OP_CONV_ID] = {"", "conv.id", ev_integer, ev_invalid, ev_double, PROG_VERSION, "%Ga, %gc", }, - [OP_CONV_DI] = {"", "conv.di", false, + [OP_CONV_DI] = {"", "conv.di", ev_double, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_CONV_FD] = {"", "conv.fd", false, + [OP_CONV_FD] = {"", "conv.fd", ev_float, ev_invalid, ev_double, PROG_VERSION, "%Ga, %gc", }, - [OP_CONV_DF] = {"", "conv.df", false, + [OP_CONV_DF] = {"", "conv.df", ev_double, ev_invalid, ev_float, PROG_VERSION, "%Ga, %gc", }, - [OP_STORE_D] = {"=", "store.d", true, + [OP_STORE_D] = {"=", "store.d", ev_double, ev_double, ev_invalid, PROG_VERSION, "%Ga, %gb", }, - [OP_STORE_F] = {"=", "store.f", true, + [OP_STORE_F] = {"=", "store.f", ev_float, ev_float, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_V] = {"=", "store.v", true, + [OP_STORE_V] = {"=", "store.v", ev_vector, ev_vector, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_Q] = {"=", "store.q", true, + [OP_STORE_Q] = {"=", "store.q", ev_quat, ev_quat, ev_invalid, PROG_VERSION, "%Ga, %gb", }, - [OP_STORE_S] = {"=", "store.s", true, + [OP_STORE_S] = {"=", "store.s", ev_string, ev_string, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_ENT] = {"=", "store.ent", true, + [OP_STORE_ENT] = {"=", "store.ent", ev_entity, ev_entity, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_FLD] = {"=", "store.fld", true, + [OP_STORE_FLD] = {"=", "store.fld", ev_field, ev_field, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_FN] = {"=", "store.fn", true, + [OP_STORE_FN] = {"=", "store.fn", ev_func, ev_func, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_I] = {"=", "store.i", true, + [OP_STORE_I] = {"=", "store.i", ev_integer, ev_integer, ev_invalid, PROG_VERSION, "%Ga, %gb", }, - [OP_STORE_P] = {"=", "store.p", true, + [OP_STORE_P] = {"=", "store.p", ev_pointer, ev_pointer, ev_invalid, PROG_VERSION, "%Ga, %gb", }, - [OP_STOREP_D] = {".=", "storep.d", true, + [OP_STOREP_D] = {".=", "storep.d", ev_double, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_F] = {".=", "storep.f", true, + [OP_STOREP_F] = {".=", "storep.f", ev_float, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_V] = {".=", "storep.v", true, + [OP_STOREP_V] = {".=", "storep.v", ev_vector, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_Q] = {".=", "storep.q", true, + [OP_STOREP_Q] = {".=", "storep.q", ev_quat, ev_pointer, ev_invalid, PROG_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_S] = {".=", "storep.s", true, + [OP_STOREP_S] = {".=", "storep.s", ev_string, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_ENT] = {".=", "storep.ent", true, + [OP_STOREP_ENT] = {".=", "storep.ent", ev_entity, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_FLD] = {".=", "storep.fld", true, + [OP_STOREP_FLD] = {".=", "storep.fld", ev_field, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_FN] = {".=", "storep.fn", true, + [OP_STOREP_FN] = {".=", "storep.fn", ev_func, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_I] = {".=", "storep.i", true, + [OP_STOREP_I] = {".=", "storep.i", ev_integer, ev_pointer, ev_invalid, PROG_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_P] = {".=", "storep.p", true, + [OP_STOREP_P] = {".=", "storep.p", ev_pointer, ev_pointer, ev_invalid, PROG_VERSION, "%Ga, *%Gb", }, - [OP_STOREB_D] = {".=", "storeb.d", true, + [OP_STOREB_D] = {".=", "storeb.d", ev_double, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_F] = {".=", "storeb.f", true, + [OP_STOREB_F] = {".=", "storeb.f", ev_float, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_V] = {".=", "storeb.v", true, + [OP_STOREB_V] = {".=", "storeb.v", ev_vector, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_Q] = {".=", "storeb.q", true, + [OP_STOREB_Q] = {".=", "storeb.q", ev_quat, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_S] = {".=", "storeb.s", true, + [OP_STOREB_S] = {".=", "storeb.s", ev_string, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_ENT] = {".=", "storeb.ent", true, + [OP_STOREB_ENT] = {".=", "storeb.ent", ev_entity, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_FLD] = {".=", "storeb.fld", true, + [OP_STOREB_FLD] = {".=", "storeb.fld", ev_field, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_FN] = {".=", "storeb.fn", true, + [OP_STOREB_FN] = {".=", "storeb.fn", ev_func, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_I] = {".=", "storeb.i", true, + [OP_STOREB_I] = {".=", "storeb.i", ev_integer, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_P] = {".=", "storeb.p", true, + [OP_STOREB_P] = {".=", "storeb.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREBI_D] = {".=", "storebi.d", true, + [OP_STOREBI_D] = {".=", "storebi.d", ev_double, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_F] = {".=", "storebi.f", true, + [OP_STOREBI_F] = {".=", "storebi.f", ev_float, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_V] = {".=", "storebi.v", true, + [OP_STOREBI_V] = {".=", "storebi.v", ev_vector, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_Q] = {".=", "storebi.q", true, + [OP_STOREBI_Q] = {".=", "storebi.q", ev_quat, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_S] = {".=", "storebi.s", true, + [OP_STOREBI_S] = {".=", "storebi.s", ev_string, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_ENT] = {".=", "storebi.ent", true, + [OP_STOREBI_ENT] = {".=", "storebi.ent", ev_entity, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_FLD] = {".=", "storebi.fld", true, + [OP_STOREBI_FLD] = {".=", "storebi.fld", ev_field, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_FN] = {".=", "storebi.fn", true, + [OP_STOREBI_FN] = {".=", "storebi.fn", ev_func, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_I] = {".=", "storebi.i", true, + [OP_STOREBI_I] = {".=", "storebi.i", ev_integer, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_P] = {".=", "storebi.p", true, + [OP_STOREBI_P] = {".=", "storebi.p", ev_pointer, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_RETURN] = {"", "return", false, + [OP_RETURN] = {"", "return", ev_void, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Ra", }, - [OP_RETURN_V] = {"", "return", false, + [OP_RETURN_V] = {"", "return", ev_invalid, ev_invalid, ev_invalid, PROG_VERSION, "", }, - [OP_NOT_D] = {"!", "not.d", false, + [OP_NOT_D] = {"!", "not.d", ev_double, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_NOT_F] = {"!", "not.f", false, + [OP_NOT_F] = {"!", "not.f", ev_float, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_V] = {"!", "not.v", false, + [OP_NOT_V] = {"!", "not.v", ev_vector, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_Q] = {"!", "not.q", false, + [OP_NOT_Q] = {"!", "not.q", ev_quat, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_NOT_S] = {"!", "not.s", false, + [OP_NOT_S] = {"!", "not.s", ev_string, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_ENT] = {"!", "not.ent", false, + [OP_NOT_ENT] = {"!", "not.ent", ev_entity, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_FN] = {"!", "not.fn", false, + [OP_NOT_FN] = {"!", "not.fn", ev_func, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_P] = {"!", "not.p", false, + [OP_NOT_P] = {"!", "not.p", ev_pointer, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_IF] = {"", "if", false, + [OP_IF] = {"", "if", ev_integer, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFNOT] = {"", "ifnot", false, + [OP_IFNOT] = {"", "ifnot", ev_integer, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFBE] = {"", "ifbe", true, + [OP_IFBE] = {"", "ifbe", ev_integer, ev_short, ev_invalid, PROG_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFB] = {"", "ifb", true, + [OP_IFB] = {"", "ifb", ev_integer, ev_short, ev_invalid, PROG_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFAE] = {"", "ifae", true, + [OP_IFAE] = {"", "ifae", ev_integer, ev_short, ev_invalid, PROG_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFA] = {"", "ifa", true, + [OP_IFA] = {"", "ifa", ev_integer, ev_short, ev_invalid, PROG_VERSION, "%Ga branch %sb (%Ob)", }, // calls returns REG_RETURN - [OP_CALL0] = {"", "call0", false, + [OP_CALL0] = {"", "call0", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa ()", }, - [OP_CALL1] = {"", "call1", false, + [OP_CALL1] = {"", "call1", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x)", }, - [OP_CALL2] = {"", "call2", false, + [OP_CALL2] = {"", "call2", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x)", }, - [OP_CALL3] = {"", "call3", false, + [OP_CALL3] = {"", "call3", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x)", }, - [OP_CALL4] = {"", "call4", false, + [OP_CALL4] = {"", "call4", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x)", }, - [OP_CALL5] = {"", "call5", false, + [OP_CALL5] = {"", "call5", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x)", }, - [OP_CALL6] = {"", "call6", false, + [OP_CALL6] = {"", "call6", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x)", }, - [OP_CALL7] = {"", "call7", false, + [OP_CALL7] = {"", "call7", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x, %P6x)", }, - [OP_CALL8] = {"", "call8", false, + [OP_CALL8] = {"", "call8", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x, %P6x, %P7x)", }, - [OP_RCALL0] = {"", 0, false, + [OP_RCALL0] = {"", 0, ev_invalid, ev_invalid, ev_invalid, ~0, // not a valid instruction 0, }, - [OP_RCALL1] = {"", "rcall1", false, + [OP_RCALL1] = {"", "rcall1", ev_func, ev_void, ev_invalid, PROG_VERSION, "%Fa (%P0b)", }, - [OP_RCALL2] = {"", "rcall2", false, + [OP_RCALL2] = {"", "rcall2", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c)", }, - [OP_RCALL3] = {"", "rcall3", false, + [OP_RCALL3] = {"", "rcall3", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x)", }, - [OP_RCALL4] = {"", "rcall4", false, + [OP_RCALL4] = {"", "rcall4", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x)", }, - [OP_RCALL5] = {"", "rcall5", false, + [OP_RCALL5] = {"", "rcall5", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x)", }, - [OP_RCALL6] = {"", "rcall6", false, + [OP_RCALL6] = {"", "rcall6", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x)", }, - [OP_RCALL7] = {"", "rcall7", false, + [OP_RCALL7] = {"", "rcall7", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x)", }, - [OP_RCALL8] = {"", "rcall8", false, + [OP_RCALL8] = {"", "rcall8", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x, %P7x)", }, - [OP_STATE] = {"", "state", false, + [OP_STATE] = {"", "state", ev_float, ev_func, ev_invalid, PROG_ID_VERSION, "%Ga, %Gb", }, - [OP_STATE_F] = {"", "state.f", false, + [OP_STATE_F] = {"", "state.f", ev_float, ev_func, ev_float, PROG_VERSION, "%Ga, %Gb, %Gc", }, - [OP_GOTO] = {"", "goto", false, + [OP_GOTO] = {"", "goto", ev_short, ev_invalid, ev_invalid, PROG_ID_VERSION, "branch %sa (%Oa)", }, - [OP_JUMP] = {"", "jump", false, + [OP_JUMP] = {"", "jump", ev_integer, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_JUMPB] = {"", "jumpb", false, + [OP_JUMPB] = {"", "jumpb", ev_void, ev_integer, ev_invalid, PROG_VERSION, "%Ga[%Gb]", }, - [OP_AND] = {"&&", "and.f", false, + [OP_AND] = {"&&", "and.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_OR] = {"||", "or.f", false, + [OP_OR] = {"||", "or.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_SHL_F] = {"<<", "shl.f", false, + [OP_SHL_F] = {"<<", "shl.f", ev_float, ev_float, ev_float, PROG_VERSION, }, - [OP_SHR_F] = {">>", "shr.f", false, + [OP_SHR_F] = {">>", "shr.f", ev_float, ev_float, ev_float, PROG_VERSION, }, - [OP_SHL_I] = {"<<", "shl.i", false, + [OP_SHL_I] = {"<<", "shl.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_SHR_I] = {">>", "shr.i", false, + [OP_SHR_I] = {">>", "shr.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_SHR_U] = {">>", "shr.u", false, + [OP_SHR_U] = {">>", "shr.u", ev_uinteger, ev_integer, ev_uinteger, PROG_VERSION, }, - [OP_BITAND] = {"&", "bitand", false, + [OP_BITAND] = {"&", "bitand", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_BITOR] = {"|", "bitor", false, + [OP_BITOR] = {"|", "bitor", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_ADD_I] = {"+", "add.i", false, + [OP_ADD_I] = {"+", "add.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_SUB_I] = {"-", "sub.i", false, + [OP_SUB_I] = {"-", "sub.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_MUL_I] = {"*", "mul.i", false, + [OP_MUL_I] = {"*", "mul.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_DIV_I] = {"/", "div.i", false, + [OP_DIV_I] = {"/", "div.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_REM_I] = {"%", "rem.i", false, + [OP_REM_I] = {"%", "rem.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_MOD_I] = {"%%", "mod.i", false, + [OP_MOD_I] = {"%%", "mod.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_BITAND_I] = {"&", "bitand.i", false, + [OP_BITAND_I] = {"&", "bitand.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_BITOR_I] = {"|", "bitor.i", false, + [OP_BITOR_I] = {"|", "bitor.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_REM_F] = {"%", "rem.f", false, + [OP_REM_F] = {"%", "rem.f", ev_float, ev_float, ev_float, PROG_VERSION, }, - [OP_MOD_F] = {"%%", "mod.f", false, + [OP_MOD_F] = {"%%", "mod.f", ev_float, ev_float, ev_float, PROG_VERSION, }, - [OP_GE_I] = {">=", "ge.i", false, + [OP_GE_I] = {">=", "ge.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_LE_I] = {"<=", "le.i", false, + [OP_LE_I] = {"<=", "le.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_GT_I] = {">", "gt.i", false, + [OP_GT_I] = {">", "gt.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_LT_I] = {"<", "lt.i", false, + [OP_LT_I] = {"<", "lt.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_AND_I] = {"&&", "and.i", false, + [OP_AND_I] = {"&&", "and.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_OR_I] = {"||", "or.i", false, + [OP_OR_I] = {"||", "or.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_NOT_I] = {"!", "not.i", false, + [OP_NOT_I] = {"!", "not.i", ev_integer, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_EQ_I] = {"==", "eq.i", false, + [OP_EQ_I] = {"==", "eq.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_NE_I] = {"!=", "ne.i", false, + [OP_NE_I] = {"!=", "ne.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_GE_U] = {">=", "ge.u", false, + [OP_GE_U] = {">=", "ge.u", ev_uinteger, ev_uinteger, ev_integer, PROG_VERSION, }, - [OP_LE_U] = {"<=", "le.u", false, + [OP_LE_U] = {"<=", "le.u", ev_uinteger, ev_uinteger, ev_integer, PROG_VERSION, }, - [OP_GT_U] = {">", "gt.u", false, + [OP_GT_U] = {">", "gt.u", ev_uinteger, ev_uinteger, ev_integer, PROG_VERSION, }, - [OP_LT_U] = {"<", "lt.u", false, + [OP_LT_U] = {"<", "lt.u", ev_uinteger, ev_uinteger, ev_integer, PROG_VERSION, }, - [OP_BITXOR_F] = {"^", "bitxor.f", false, + [OP_BITXOR_F] = {"^", "bitxor.f", ev_float, ev_float, ev_float, PROG_VERSION, }, - [OP_BITNOT_F] = {"~", "bitnot.f", false, + [OP_BITNOT_F] = {"~", "bitnot.f", ev_float, ev_invalid, ev_float, PROG_VERSION, "%Ga, %gc", }, - [OP_BITXOR_I] = {"^", "bitxor.i", false, + [OP_BITXOR_I] = {"^", "bitxor.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_BITNOT_I] = {"~", "bitnot.i", false, + [OP_BITNOT_I] = {"~", "bitnot.i", ev_integer, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_GE_P] = {">=", "ge.p", false, + [OP_GE_P] = {">=", "ge.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - [OP_LE_P] = {"<=", "le.p", false, + [OP_LE_P] = {"<=", "le.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - [OP_GT_P] = {">", "gt.p", false, + [OP_GT_P] = {">", "gt.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - [OP_LT_P] = {"<", "lt.p", false, + [OP_LT_P] = {"<", "lt.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - [OP_EQ_P] = {"==", "eq.p", false, + [OP_EQ_P] = {"==", "eq.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - [OP_NE_P] = {"!=", "ne.p", false, + [OP_NE_P] = {"!=", "ne.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - [OP_MOVEI] = {"", "movei", true, + [OP_MOVEI] = {"", "movei", ev_void, ev_short, ev_void, PROG_VERSION, "%Ga, %sb, %gc", }, - [OP_MOVEP] = {"", "movep", true, + [OP_MOVEP] = {"", "movep", ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "%Ga, %Gb, %Gc", }, - [OP_MOVEPI] = {"", "movepi", true, + [OP_MOVEPI] = {"", "movepi", ev_pointer, ev_short, ev_pointer, PROG_VERSION, "%Ga, %sb, %Gc", }, - [OP_MEMSETI] = {"", "memseti", true, + [OP_MEMSETI] = {"", "memseti", ev_integer, ev_short, ev_void, PROG_VERSION, "%Ga, %sb, %gc", }, - [OP_MEMSETP] = {"", "memsetp", true, + [OP_MEMSETP] = {"", "memsetp", ev_integer, ev_integer, ev_pointer, PROG_VERSION, "%Ga, %Gb, %Gc", }, - [OP_MEMSETPI] = {"", "memsetpi", true, + [OP_MEMSETPI] = {"", "memsetpi", ev_integer, ev_short, ev_pointer, PROG_VERSION, "%Ga, %sb, %Gc", }, - [OP_PUSH_S] = {"", "push.s", false, + [OP_PUSH_S] = {"", "push.s", ev_string, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_F] = {"", "push.f", false, + [OP_PUSH_F] = {"", "push.f", ev_float, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_V] = {"", "push.v", false, + [OP_PUSH_V] = {"", "push.v", ev_vector, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_ENT] = {"", "push.ent", false, + [OP_PUSH_ENT] = {"", "push.ent", ev_entity, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_FLD] = {"", "push.fld", false, + [OP_PUSH_FLD] = {"", "push.fld", ev_field, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_FN] = {"", "push.fn", false, + [OP_PUSH_FN] = {"", "push.fn", ev_func, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_P] = {"", "push.p", false, + [OP_PUSH_P] = {"", "push.p", ev_pointer, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_Q] = {"", "push.q", false, + [OP_PUSH_Q] = {"", "push.q", ev_quat, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_I] = {"", "push.i", false, + [OP_PUSH_I] = {"", "push.i", ev_integer, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_D] = {"", "push.d", false, + [OP_PUSH_D] = {"", "push.d", ev_double, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSHB_S] = {"", "pushb.s", false, + [OP_PUSHB_S] = {"", "pushb.s", ev_pointer, ev_integer, ev_string, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_F] = {"", "pushb.f", false, + [OP_PUSHB_F] = {"", "pushb.f", ev_pointer, ev_integer, ev_float, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_V] = {"", "pushb.v", false, + [OP_PUSHB_V] = {"", "pushb.v", ev_pointer, ev_integer, ev_vector, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_ENT] = {"", "pushb.ent", false, + [OP_PUSHB_ENT] = {"", "pushb.ent", ev_pointer, ev_integer, ev_entity, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_FLD] = {"", "pushb.fld", false, + [OP_PUSHB_FLD] = {"", "pushb.fld", ev_pointer, ev_integer, ev_field, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_FN] = {"", "pushb.fn", false, + [OP_PUSHB_FN] = {"", "pushb.fn", ev_pointer, ev_integer, ev_func, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_P] = {"", "pushb.p", false, + [OP_PUSHB_P] = {"", "pushb.p", ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_Q] = {"", "pushb.q", false, + [OP_PUSHB_Q] = {"", "pushb.q", ev_pointer, ev_integer, ev_quat, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_I] = {"", "pushb.i", false, + [OP_PUSHB_I] = {"", "pushb.i", ev_pointer, ev_integer, ev_integer, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_D] = {"", "pushb.d", false, + [OP_PUSHB_D] = {"", "pushb.d", ev_pointer, ev_integer, ev_double, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHBI_S] = {"", "pushbi.s", false, + [OP_PUSHBI_S] = {"", "pushbi.s", ev_pointer, ev_short, ev_string, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_F] = {"", "pushbi.f", false, + [OP_PUSHBI_F] = {"", "pushbi.f", ev_pointer, ev_short, ev_float, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_V] = {"", "pushbi.v", false, + [OP_PUSHBI_V] = {"", "pushbi.v", ev_pointer, ev_short, ev_vector, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_ENT] = {"", "pushbi.ent", false, + [OP_PUSHBI_ENT] = {"", "pushbi.ent", ev_pointer, ev_short, ev_entity, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_FLD] = {"", "pushbi.fld", false, + [OP_PUSHBI_FLD] = {"", "pushbi.fld", ev_pointer, ev_short, ev_field, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_FN] = {"", "pushbi.fn", false, + [OP_PUSHBI_FN] = {"", "pushbi.fn", ev_pointer, ev_short, ev_func, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_P] = {"", "pushbi.p", false, + [OP_PUSHBI_P] = {"", "pushbi.p", ev_pointer, ev_short, ev_pointer, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_Q] = {"", "pushbi.q", false, + [OP_PUSHBI_Q] = {"", "pushbi.q", ev_pointer, ev_short, ev_quat, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_I] = {"", "pushbi.i", false, + [OP_PUSHBI_I] = {"", "pushbi.i", ev_pointer, ev_short, ev_integer, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_D] = {"", "pushbi.d", false, + [OP_PUSHBI_D] = {"", "pushbi.d", ev_pointer, ev_short, ev_double, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POP_S] = {"", "pop.s", false, + [OP_POP_S] = {"", "pop.s", ev_string, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_F] = {"", "pop.f", false, + [OP_POP_F] = {"", "pop.f", ev_float, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_V] = {"", "pop.v", false, + [OP_POP_V] = {"", "pop.v", ev_vector, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_ENT] = {"", "pop.ent", false, + [OP_POP_ENT] = {"", "pop.ent", ev_entity, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_FLD] = {"", "pop.fld", false, + [OP_POP_FLD] = {"", "pop.fld", ev_field, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_FN] = {"", "pop.fn", false, + [OP_POP_FN] = {"", "pop.fn", ev_func, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_P] = {"", "pop.p", false, + [OP_POP_P] = {"", "pop.p", ev_pointer, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_Q] = {"", "pop.q", false, + [OP_POP_Q] = {"", "pop.q", ev_quat, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_I] = {"", "pop.i", false, + [OP_POP_I] = {"", "pop.i", ev_integer, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_D] = {"", "pop.d", false, + [OP_POP_D] = {"", "pop.d", ev_double, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POPB_S] = {"", "popb.s", false, + [OP_POPB_S] = {"", "popb.s", ev_pointer, ev_integer, ev_string, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_F] = {"", "popb.f", false, + [OP_POPB_F] = {"", "popb.f", ev_pointer, ev_integer, ev_float, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_V] = {"", "popb.v", false, + [OP_POPB_V] = {"", "popb.v", ev_pointer, ev_integer, ev_vector, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_ENT] = {"", "popb.ent", false, + [OP_POPB_ENT] = {"", "popb.ent", ev_pointer, ev_integer, ev_entity, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_FLD] = {"", "popb.fld", false, + [OP_POPB_FLD] = {"", "popb.fld", ev_pointer, ev_integer, ev_field, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_FN] = {"", "popb.fn", false, + [OP_POPB_FN] = {"", "popb.fn", ev_pointer, ev_integer, ev_func, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_P] = {"", "popb.p", false, + [OP_POPB_P] = {"", "popb.p", ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_Q] = {"", "popb.q", false, + [OP_POPB_Q] = {"", "popb.q", ev_pointer, ev_integer, ev_quat, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_I] = {"", "popb.i", false, + [OP_POPB_I] = {"", "popb.i", ev_pointer, ev_integer, ev_integer, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_D] = {"", "popb.d", false, + [OP_POPB_D] = {"", "popb.d", ev_pointer, ev_integer, ev_double, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPBI_S] = {"", "popbi.s", false, + [OP_POPBI_S] = {"", "popbi.s", ev_pointer, ev_short, ev_string, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_F] = {"", "popbi.f", false, + [OP_POPBI_F] = {"", "popbi.f", ev_pointer, ev_short, ev_float, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_V] = {"", "popbi.v", false, + [OP_POPBI_V] = {"", "popbi.v", ev_pointer, ev_short, ev_vector, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_ENT] = {"", "popbi.ent", false, + [OP_POPBI_ENT] = {"", "popbi.ent", ev_pointer, ev_short, ev_entity, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_FLD] = {"", "popbi.fld", false, + [OP_POPBI_FLD] = {"", "popbi.fld", ev_pointer, ev_short, ev_field, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_FN] = {"", "popbi.fn", false, + [OP_POPBI_FN] = {"", "popbi.fn", ev_pointer, ev_short, ev_func, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_P] = {"", "popbi.p", false, + [OP_POPBI_P] = {"", "popbi.p", ev_pointer, ev_short, ev_pointer, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_Q] = {"", "popbi.q", false, + [OP_POPBI_Q] = {"", "popbi.q", ev_pointer, ev_short, ev_quat, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_I] = {"", "popbi.i", false, + [OP_POPBI_I] = {"", "popbi.i", ev_pointer, ev_short, ev_integer, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_D] = {"", "popbi.d", false, + [OP_POPBI_D] = {"", "popbi.d", ev_pointer, ev_short, ev_double, PROG_VERSION, "*(%Ga + %sb)", From 7b0eceda326f40fae2ee6813e7d395875f47f260 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 2 Jan 2022 20:16:45 +0900 Subject: [PATCH 013/360] [gamecode] Split out the old quake c execution loop There is no reasonable way (due to hardware-enforced alignment issues) to simply convert old bytecode to new (probably best done with an off-line tool, preferably just recompiling when I get qfcc up to the job), so both loops will need to be present. This just moves the original loop into its own function in order to make it easy to bring in the new (and iron out integration issues). --- libs/gamecode/pr_exec.c | 50 ++++++++++++++++++++++++----------------- 1 file changed, 29 insertions(+), 21 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index af7517a92..b9367b74c 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -436,15 +436,10 @@ pr_memset (pr_type_t *dst, int val, int count) } } -/* - PR_ExecuteProgram - - The interpretation main loop -*/ -VISIBLE void -PR_ExecuteProgram (progs_t *pr, func_t fnum) +static void +pr_exec_quakec (progs_t *pr, int exitdepth) { - int exitdepth, profile, startprofile; + int profile, startprofile; int fldofs; pr_uint_t pointer; dstatement_t *st; @@ -452,26 +447,13 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum) pr_type_t old_val = {0}; // make a stack frame - exitdepth = pr->pr_depth; startprofile = profile = 0; - Sys_PushSignalHook (signal_hook, pr); - Sys_PushErrorHandler (error_handler, pr); - - if (pr->debug_handler) { - pr->debug_handler (prd_subenter, &fnum, pr->debug_data); - } - - if (!PR_CallFunction (pr, fnum)) { - // called a builtin instead of progs code - goto exit_program; - } st = pr->pr_statements + pr->pr_xstatement; if (pr->watch) { old_val = *pr->watch; } - while (1) { pr_type_t *op_a, *op_b, *op_c; @@ -1737,6 +1719,32 @@ op_call: old_val.integer_var = pr->watch->integer_var; } } +exit_program: +} + +/* + PR_ExecuteProgram + + The interpretation main loop +*/ +VISIBLE void +PR_ExecuteProgram (progs_t *pr, func_t fnum) +{ + Sys_PushSignalHook (signal_hook, pr); + Sys_PushErrorHandler (error_handler, pr); + + if (pr->debug_handler) { + pr->debug_handler (prd_subenter, &fnum, pr->debug_data); + } + + int exitdepth = pr->pr_depth; + if (!PR_CallFunction (pr, fnum)) { + // called a builtin instead of progs code + goto exit_program; + } + if (1) { + pr_exec_quakec (pr, exitdepth); + } exit_program: if (pr->debug_handler) { pr->debug_handler (prd_subexit, 0, pr->debug_data); From bc0a09f452019e3f3f4a86941ea93c67a1e265e7 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 2 Jan 2022 20:46:32 +0900 Subject: [PATCH 014/360] [gamecode] Switch to using type parameter op macros I wish I'd done it this way years ago (but maybe gcc 2.95 couldn't hack the casts, I do know there were aliasing problems in the past). Anyway, this makes operand access much more consistent for variable sized operands (eg float vs double vs vec4), and is a big part of the new instruction set implementation. --- include/QF/progs.h | 4 +- libs/gamecode/pr_debug.c | 2 +- libs/gamecode/pr_edict.c | 4 +- libs/gamecode/pr_exec.c | 531 +++++++++++++++++++-------------------- 4 files changed, 266 insertions(+), 275 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 3f6ad6ae3..8d32e2074 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -289,7 +289,7 @@ void ED_Free (progs_t *pr, edict_t *ed); edict_t *ED_EdictNum(progs_t *pr, pr_int_t n) __attribute__((pure)); pr_int_t ED_NumForEdict(progs_t *pr, edict_t *e) __attribute__((pure)); void ED_Count (progs_t *pr); -qboolean PR_EdictValid (progs_t *pr, pr_int_t e) __attribute__((pure)); +qboolean PR_EdictValid (progs_t *pr, pr_uint_t e) __attribute__((pure)); // pr_debug.c void ED_Print (progs_t *pr, edict_t *ed, const char *fieldname); @@ -1900,7 +1900,7 @@ struct progs_s { void (*free_edict) (progs_t *pr, edict_t *ent); pr_type_t *pr_edict_area; int pr_edict_size; ///< # of pr_type_t slots - int pr_edict_area_size; ///< for bounds checking, starts at 0 + pr_uint_t pr_edict_area_size; ///< for bounds checking, starts at 0 func_t edict_parse; ///@} diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 55cca36d0..a720a863d 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -1536,7 +1536,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) const char *str; char mode = fmt[1], opchar = fmt[2]; unsigned parm_ind = 0; - pr_int_t opval; + pr_uint_t opval; qfot_type_t *optype = &res->void_type; func_t func; diff --git a/libs/gamecode/pr_edict.c b/libs/gamecode/pr_edict.c index 60233a0ce..f16c2bd41 100644 --- a/libs/gamecode/pr_edict.c +++ b/libs/gamecode/pr_edict.c @@ -241,12 +241,12 @@ ED_NumForEdict (progs_t *pr, edict_t *e) } qboolean -PR_EdictValid (progs_t *pr, pr_int_t e) +PR_EdictValid (progs_t *pr, pr_uint_t e) { if (!pr->num_edicts) { return false; } - if (e < 0 || e >= pr->pr_edict_area_size) + if (e >= pr->pr_edict_area_size) return false; if (e % pr->pr_edict_size) return false; diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index b9367b74c..fa226a417 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -330,19 +330,15 @@ PR_BoundsCheck (progs_t *pr, int addr, etype_t type) PR_BoundsCheckSize (pr, addr, pr_type_size[type]); } -#define OPA (*op_a) -#define OPB (*op_b) -#define OPC (*op_c) - -#define OPA_double_var (*((double *) (op_a))) -#define OPB_double_var (*((double *) (op_b))) -#define OPC_double_var (*((double *) (op_c))) +#define OPA(type) (*((pr_##type##_t *) (op_a))) +#define OPB(type) (*((pr_##type##_t *) (op_b))) +#define OPC(type) (*((pr_##type##_t *) (op_c))) /* This gets around the problem of needing to test for -0.0 but denormals causing exceptions (or wrong results for what we need) on the alpha. */ -#define FNZ(x) ((x).uinteger_var & ~0x80000000u) +#define FNZ(x) ((x) & ~0x80000000u) static int signal_hook (int sig, void *data) @@ -360,23 +356,23 @@ signal_hook (int sig, void *data) switch (st->op) { case OP_DIV_F: - if ((OPA.integer_var & 0x80000000) - ^ (OPB.integer_var & 0x80000000)) - OPC.integer_var = 0xff7fffff; + if ((OPA(int) & 0x80000000) + ^ (OPB(int) & 0x80000000)) + OPC(int) = 0xff7fffff; else - OPC.integer_var = 0x7f7fffff; + OPC(int) = 0x7f7fffff; return 1; case OP_DIV_I: - if (OPA.integer_var & 0x80000000) - OPC.integer_var = -0x80000000; + if (OPA(int) & 0x80000000) + OPC(int) = -0x80000000; else - OPC.integer_var = 0x7fffffff; + OPC(int) = 0x7fffffff; return 1; case OP_MOD_I: case OP_MOD_F: case OP_REM_I: case OP_REM_F: - OPC.integer_var = 0x00000000; + OPC(int) = 0x00000000; return 1; default: break; @@ -488,214 +484,214 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr_opcode_e op = st->op & ~OP_BREAK; switch (op) { case OP_ADD_D: - OPC_double_var = OPA_double_var + OPB_double_var; + OPC(double) = OPA(double) + OPB(double); break; case OP_ADD_F: - OPC.float_var = OPA.float_var + OPB.float_var; + OPC(float) = OPA(float) + OPB(float); break; case OP_ADD_V: - VectorAdd (&OPA.vector_var, &OPB.vector_var, &OPC.vector_var); + VectorAdd (&OPA(float), &OPB(float), &OPC(float)); break; case OP_ADD_Q: - QuatAdd (&OPA.quat_var, &OPB.quat_var, &OPC.quat_var); + QuatAdd (&OPA(float), &OPB(float), &OPC(float)); break; case OP_ADD_S: - OPC.string_var = PR_CatStrings (pr, + OPC(string) = PR_CatStrings (pr, PR_GetString (pr, - OPA.string_var), + OPA(string)), PR_GetString (pr, - OPB.string_var)); + OPB(string))); break; case OP_SUB_D: - OPC_double_var = OPA_double_var - OPB_double_var; + OPC(double) = OPA(double) - OPB(double); break; case OP_SUB_F: - OPC.float_var = OPA.float_var - OPB.float_var; + OPC(float) = OPA(float) - OPB(float); break; case OP_SUB_V: - VectorSubtract (&OPA.vector_var, &OPB.vector_var, - &OPC.vector_var); + VectorSubtract (&OPA(float), &OPB(float), + &OPC(float)); break; case OP_SUB_Q: - QuatSubtract (&OPA.quat_var, &OPB.quat_var, &OPC.quat_var); + QuatSubtract (&OPA(float), &OPB(float), &OPC(float)); break; case OP_MUL_D: - OPC_double_var = OPA_double_var * OPB_double_var; + OPC(double) = OPA(double) * OPB(double); break; case OP_MUL_F: - OPC.float_var = OPA.float_var * OPB.float_var; + OPC(float) = OPA(float) * OPB(float); break; case OP_MUL_V: - OPC.float_var = DotProduct (&OPA.vector_var, &OPB.vector_var); + OPC(float) = DotProduct (&OPA(float), &OPB(float)); break; case OP_MUL_DV: { // avoid issues with the likes of x = x.x * x; // makes for faster code, too - double scale = OPA_double_var; - VectorScale (&OPB.vector_var, scale, &OPC.vector_var); + double scale = OPA(double); + VectorScale (&OPB(float), scale, &OPC(float)); } break; case OP_MUL_VD: { // avoid issues with the likes of x = x * x.x; // makes for faster code, too - double scale = OPB_double_var; - VectorScale (&OPA.vector_var, scale, &OPC.vector_var); + double scale = OPB(double); + VectorScale (&OPA(float), scale, &OPC(float)); } break; case OP_MUL_FV: { // avoid issues with the likes of x = x.x * x; // makes for faster code, too - float scale = OPA.float_var; - VectorScale (&OPB.vector_var, scale, &OPC.vector_var); + float scale = OPA(float); + VectorScale (&OPB(float), scale, &OPC(float)); } break; case OP_MUL_VF: { // avoid issues with the likes of x = x * x.x; // makes for faster code, too - float scale = OPB.float_var; - VectorScale (&OPA.vector_var, scale, &OPC.vector_var); + float scale = OPB(float); + VectorScale (&OPA(float), scale, &OPC(float)); } break; case OP_MUL_Q: - QuatMult (&OPA.quat_var, &OPB.quat_var, &OPC.quat_var); + QuatMult (&OPA(float), &OPB(float), &OPC(float)); break; case OP_MUL_QV: - QuatMultVec (&OPA.quat_var, &OPB.vector_var, &OPC.vector_var); + QuatMultVec (&OPA(float), &OPB(float), &OPC(float)); break; case OP_MUL_DQ: { // avoid issues with the likes of x = x.s * x; // makes for faster code, too - double scale = OPA_double_var; - QuatScale (&OPB.quat_var, scale, &OPC.quat_var); + double scale = OPA(double); + QuatScale (&OPB(float), scale, &OPC(float)); } break; case OP_MUL_QD: { // avoid issues with the likes of x = x * x.s; // makes for faster code, too - double scale = OPB_double_var; - QuatScale (&OPA.quat_var, scale, &OPC.quat_var); + double scale = OPB(double); + QuatScale (&OPA(float), scale, &OPC(float)); } break; case OP_MUL_FQ: { // avoid issues with the likes of x = x.s * x; // makes for faster code, too - float scale = OPA.float_var; - QuatScale (&OPB.quat_var, scale, &OPC.quat_var); + float scale = OPA(float); + QuatScale (&OPB(float), scale, &OPC(float)); } break; case OP_MUL_QF: { // avoid issues with the likes of x = x * x.s; // makes for faster code, too - float scale = OPB.float_var; - QuatScale (&OPA.quat_var, scale, &OPC.quat_var); + float scale = OPB(float); + QuatScale (&OPA(float), scale, &OPC(float)); } break; case OP_CONJ_Q: - QuatConj (&OPA.quat_var, &OPC.quat_var); + QuatConj (&OPA(float), &OPC(float)); break; case OP_DIV_D: - OPC_double_var = OPA_double_var / OPB_double_var; + OPC(double) = OPA(double) / OPB(double); break; case OP_DIV_F: - OPC.float_var = OPA.float_var / OPB.float_var; + OPC(float) = OPA(float) / OPB(float); break; case OP_BITAND: - OPC.float_var = (int) OPA.float_var & (int) OPB.float_var; + OPC(float) = (int) OPA(float) & (int) OPB(float); break; case OP_BITOR: - OPC.float_var = (int) OPA.float_var | (int) OPB.float_var; + OPC(float) = (int) OPA(float) | (int) OPB(float); break; case OP_BITXOR_F: - OPC.float_var = (int) OPA.float_var ^ (int) OPB.float_var; + OPC(float) = (int) OPA(float) ^ (int) OPB(float); break; case OP_BITNOT_F: - OPC.float_var = ~ (int) OPA.float_var; + OPC(float) = ~ (int) OPA(float); break; case OP_SHL_F: - OPC.float_var = (int) OPA.float_var << (int) OPB.float_var; + OPC(float) = (int) OPA(float) << (int) OPB(float); break; case OP_SHR_F: - OPC.float_var = (int) OPA.float_var >> (int) OPB.float_var; + OPC(float) = (int) OPA(float) >> (int) OPB(float); break; case OP_SHL_I: - OPC.integer_var = OPA.integer_var << OPB.integer_var; + OPC(int) = OPA(int) << OPB(int); break; case OP_SHR_I: - OPC.integer_var = OPA.integer_var >> OPB.integer_var; + OPC(int) = OPA(int) >> OPB(int); break; case OP_SHR_U: - OPC.uinteger_var = OPA.uinteger_var >> OPB.integer_var; + OPC(uint) = OPA(uint) >> OPB(int); break; case OP_GE_F: - OPC.float_var = OPA.float_var >= OPB.float_var; + OPC(float) = OPA(float) >= OPB(float); break; case OP_LE_F: - OPC.float_var = OPA.float_var <= OPB.float_var; + OPC(float) = OPA(float) <= OPB(float); break; case OP_GT_F: - OPC.float_var = OPA.float_var > OPB.float_var; + OPC(float) = OPA(float) > OPB(float); break; case OP_LT_F: - OPC.float_var = OPA.float_var < OPB.float_var; + OPC(float) = OPA(float) < OPB(float); break; case OP_AND: // OPA and OPB have to be float for -0.0 - OPC.integer_var = FNZ (OPA) && FNZ (OPB); + OPC(int) = FNZ (OPA(uint)) && FNZ (OPB(uint)); break; case OP_OR: // OPA and OPB have to be float for -0.0 - OPC.integer_var = FNZ (OPA) || FNZ (OPB); + OPC(int) = FNZ (OPA(uint)) || FNZ (OPB(uint)); break; case OP_NOT_F: - OPC.integer_var = !FNZ (OPA); + OPC(int) = !FNZ (OPA(uint)); break; case OP_NOT_V: - OPC.integer_var = VectorIsZero (&OPA.vector_var); + OPC(int) = VectorIsZero (&OPA(float)); break; case OP_NOT_Q: - OPC.integer_var = QuatIsZero (&OPA.quat_var); + OPC(int) = QuatIsZero (&OPA(float)); break; case OP_NOT_S: - OPC.integer_var = !OPA.string_var || - !*PR_GetString (pr, OPA.string_var); + OPC(int) = !OPA(string) || + !*PR_GetString (pr, OPA(string)); break; case OP_NOT_FN: - OPC.integer_var = !OPA.func_var; + OPC(int) = !OPA(uint); break; case OP_NOT_ENT: - OPC.integer_var = !OPA.entity_var; + OPC(int) = !OPA(uint); break; case OP_EQ_F: - OPC.integer_var = OPA.float_var == OPB.float_var; + OPC(int) = OPA(float) == OPB(float); break; case OP_EQ_V: - OPC.integer_var = VectorCompare (&OPA.vector_var, - &OPB.vector_var); + OPC(int) = VectorCompare (&OPA(float), + &OPB(float)); break; case OP_EQ_Q: - OPC.integer_var = QuatCompare (&OPA.quat_var, &OPB.quat_var); + OPC(int) = QuatCompare (&OPA(float), &OPB(float)); break; case OP_EQ_E: - OPC.integer_var = OPA.integer_var == OPB.integer_var; + OPC(int) = OPA(int) == OPB(int); break; case OP_EQ_FN: - OPC.integer_var = OPA.func_var == OPB.func_var; + OPC(int) = OPA(uint) == OPB(uint); break; case OP_NE_F: - OPC.integer_var = OPA.float_var != OPB.float_var; + OPC(int) = OPA(float) != OPB(float); break; case OP_NE_V: - OPC.integer_var = !VectorCompare (&OPA.vector_var, - &OPB.vector_var); + OPC(int) = !VectorCompare (&OPA(float), + &OPB(float)); break; case OP_NE_Q: - OPC.integer_var = !QuatCompare (&OPA.quat_var, &OPB.quat_var); + OPC(int) = !QuatCompare (&OPA(float), &OPB(float)); break; case OP_LE_S: case OP_GE_S: @@ -704,8 +700,8 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_NE_S: case OP_EQ_S: { - int cmp = strcmp (PR_GetString (pr, OPA.string_var), - PR_GetString (pr, OPB.string_var)); + int cmp = strcmp (PR_GetString (pr, OPA(string)), + PR_GetString (pr, OPB(string))); switch (st->op) { case OP_LE_S: cmp = (cmp <= 0); break; case OP_GE_S: cmp = (cmp >= 0); break; @@ -715,14 +711,14 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_EQ_S: cmp = !cmp; break; default: break; } - OPC.integer_var = cmp; + OPC(int) = cmp; } break; case OP_NE_E: - OPC.integer_var = OPA.integer_var != OPB.integer_var; + OPC(int) = OPA(int) != OPB(int); break; case OP_NE_FN: - OPC.integer_var = OPA.func_var != OPB.func_var; + OPC(int) = OPA(uint) != OPB(uint); break; // ================== @@ -733,16 +729,16 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STORE_FN: // pointers case OP_STORE_I: case OP_STORE_P: - OPB.integer_var = OPA.integer_var; + OPB(int) = OPA(int); break; case OP_STORE_V: - VectorCopy (&OPA.vector_var, &OPB.vector_var); + VectorCopy (&OPA(float), &OPB(float)); break; case OP_STORE_Q: - QuatCopy (&OPA.quat_var, &OPB.quat_var); + QuatCopy (&OPA(float), &OPB(float)); break; case OP_STORE_D: - OPB_double_var = OPA_double_var; + OPB(double) = OPA(double); break; case OP_STOREP_F: @@ -752,52 +748,51 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREP_FN: // pointers case OP_STOREP_I: case OP_STOREP_P: - pointer = OPB.integer_var; + pointer = OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_integer); } ptr = pr->pr_globals + pointer; - ptr->integer_var = OPA.integer_var; + ptr->integer_var = OPA(int); break; case OP_STOREP_V: - pointer = OPB.integer_var; + pointer = OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); } ptr = pr->pr_globals + pointer; - VectorCopy (&OPA.vector_var, &ptr->vector_var); + VectorCopy (&OPA(float), &ptr->vector_var); break; case OP_STOREP_Q: - pointer = OPB.integer_var; + pointer = OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); } ptr = pr->pr_globals + pointer; - QuatCopy (&OPA.quat_var, &ptr->quat_var); + QuatCopy (&OPA(float), &ptr->quat_var); break; case OP_STOREP_D: - pointer = OPB.integer_var; + pointer = OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_double); } ptr = pr->pr_globals + pointer; - *(double *) ptr = OPA_double_var; + *(double *) ptr = OPA(double); break; case OP_ADDRESS: if (pr_boundscheck->int_val) { - if (OPA.entity_var < 0 - || OPA.entity_var >= pr->pr_edict_area_size) + if (OPA(uint) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to address an out " "of bounds edict"); - if (OPA.entity_var == 0 && pr->null_bad) + if (OPA(uint) == 0 && pr->null_bad) PR_RunError (pr, "assignment to world entity"); - if (OPB.uinteger_var >= pr->progs->entityfields) + if (OPB(uint) >= pr->progs->entityfields) PR_RunError (pr, "Progs attempted to address an " "invalid field in an edict"); } - fldofs = OPA.entity_var + OPB.integer_var; - OPC.integer_var = &pr->pr_edict_area[fldofs] - pr->pr_globals; + fldofs = OPA(uint) + OPB(int); + OPC(int) = &pr->pr_edict_area[fldofs] - pr->pr_globals; break; case OP_ADDRESS_VOID: case OP_ADDRESS_F: @@ -810,7 +805,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_ADDRESS_I: case OP_ADDRESS_P: case OP_ADDRESS_D: - OPC.integer_var = st->a; + OPC(int) = st->a; break; case OP_LOAD_F: @@ -821,55 +816,51 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_LOAD_I: case OP_LOAD_P: if (pr_boundscheck->int_val) { - if (OPA.entity_var < 0 - || OPA.entity_var >= pr->pr_edict_area_size) + if (OPA(uint) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to read an out of " "bounds edict number"); - if (OPB.uinteger_var >= pr->progs->entityfields) + if (OPB(uint) >= pr->progs->entityfields) PR_RunError (pr, "Progs attempted to read an invalid " "field in an edict"); } - fldofs = OPA.entity_var + OPB.integer_var; - OPC.integer_var = pr->pr_edict_area[fldofs].integer_var; + fldofs = OPA(uint) + OPB(int); + OPC(int) = pr->pr_edict_area[fldofs].integer_var; break; case OP_LOAD_V: if (pr_boundscheck->int_val) { - if (OPA.entity_var < 0 - || OPA.entity_var >= pr->pr_edict_area_size) + if (OPA(uint) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to read an out of " "bounds edict number"); - if (OPB.uinteger_var + 2 >= pr->progs->entityfields) + if (OPB(uint) + 2 >= pr->progs->entityfields) PR_RunError (pr, "Progs attempted to read an invalid " "field in an edict"); } - fldofs = OPA.entity_var + OPB.integer_var; - memcpy (&OPC, &pr->pr_edict_area[fldofs], 3 * sizeof (OPC)); + fldofs = OPA(uint) + OPB(int); + memcpy (op_c, &pr->pr_edict_area[fldofs], 3 * sizeof (*op_c)); break; case OP_LOAD_Q: if (pr_boundscheck->int_val) { - if (OPA.entity_var < 0 - || OPA.entity_var >= pr->pr_edict_area_size) + if (OPA(uint) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to read an out of " "bounds edict number"); - if (OPB.uinteger_var + 3 >= pr->progs->entityfields) + if (OPB(uint) + 3 >= pr->progs->entityfields) PR_RunError (pr, "Progs attempted to read an invalid " "field in an edict"); } - fldofs = OPA.entity_var + OPB.integer_var; - memcpy (&OPC, &pr->pr_edict_area[fldofs], 4 * sizeof (OPC)); + fldofs = OPA(uint) + OPB(int); + memcpy (op_c, &pr->pr_edict_area[fldofs], 4 * sizeof (*op_c)); break; case OP_LOAD_D: if (pr_boundscheck->int_val) { - if (OPA.entity_var < 0 - || OPA.entity_var >= pr->pr_edict_area_size) + if (OPA(uint) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to read an out of " "bounds edict number"); - if (OPB.uinteger_var + 1 >= pr->progs->entityfields) + if (OPB(uint) + 1 >= pr->progs->entityfields) PR_RunError (pr, "Progs attempted to read an invalid " "field in an edict"); } - fldofs = OPA.entity_var + OPB.integer_var; - memcpy (&OPC, &pr->pr_edict_area[fldofs], sizeof (double)); + fldofs = OPA(uint) + OPB(int); + memcpy (op_c, &pr->pr_edict_area[fldofs], sizeof (double)); break; case OP_LOADB_F: @@ -879,36 +870,36 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_LOADB_FN: case OP_LOADB_I: case OP_LOADB_P: - pointer = OPA.integer_var + OPB.integer_var; + pointer = OPA(int) + OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_integer); } ptr = pr->pr_globals + pointer; - OPC.integer_var = ptr->integer_var; + OPC(int) = ptr->integer_var; break; case OP_LOADB_V: - pointer = OPA.integer_var + OPB.integer_var; + pointer = OPA(int) + OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); } ptr = pr->pr_globals + pointer; - VectorCopy (&ptr->vector_var, &OPC.vector_var); + VectorCopy (&ptr->vector_var, &OPC(float)); break; case OP_LOADB_Q: - pointer = OPA.integer_var + OPB.integer_var; + pointer = OPA(int) + OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); } ptr = pr->pr_globals + pointer; - QuatCopy (&ptr->quat_var, &OPC.quat_var); + QuatCopy (&ptr->quat_var, &OPC(float)); break; case OP_LOADB_D: - pointer = OPA.integer_var + OPB.integer_var; + pointer = OPA(int) + OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_double); } ptr = pr->pr_globals + pointer; - OPC_double_var = *(double *) ptr; + OPC(double) = *(double *) ptr; break; case OP_LOADBI_F: @@ -918,46 +909,46 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_LOADBI_FN: case OP_LOADBI_I: case OP_LOADBI_P: - pointer = OPA.integer_var + (short) st->b; + pointer = OPA(int) + (short) st->b; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_integer); } ptr = pr->pr_globals + pointer; - OPC.integer_var = ptr->integer_var; + OPC(int) = ptr->integer_var; break; case OP_LOADBI_V: - pointer = OPA.integer_var + (short) st->b; + pointer = OPA(int) + (short) st->b; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); } ptr = pr->pr_globals + pointer; - VectorCopy (&ptr->vector_var, &OPC.vector_var); + VectorCopy (&ptr->vector_var, &OPC(float)); break; case OP_LOADBI_Q: - pointer = OPA.integer_var + (short) st->b; + pointer = OPA(int) + (short) st->b; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); } ptr = pr->pr_globals + pointer; - QuatCopy (&ptr->quat_var, &OPC.quat_var); + QuatCopy (&ptr->quat_var, &OPC(float)); break; case OP_LOADBI_D: - pointer = OPA.integer_var + (short) st->b; + pointer = OPA(int) + (short) st->b; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); } ptr = pr->pr_globals + pointer; - OPC_double_var = *(double *) ptr; + OPC(double) = *(double *) ptr; break; case OP_LEA: - pointer = OPA.integer_var + OPB.integer_var; - OPC.integer_var = pointer; + pointer = OPA(int) + OPB(int); + OPC(int) = pointer; break; case OP_LEAI: - pointer = OPA.integer_var + (short) st->b; - OPC.integer_var = pointer; + pointer = OPA(int) + (short) st->b; + OPC(int) = pointer; break; case OP_STOREB_F: @@ -967,36 +958,36 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREB_FN: case OP_STOREB_I: case OP_STOREB_P: - pointer = OPB.integer_var + OPC.integer_var; + pointer = OPB(int) + OPC(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_integer); } ptr = pr->pr_globals + pointer; - ptr->integer_var = OPA.integer_var; + ptr->integer_var = OPA(int); break; case OP_STOREB_V: - pointer = OPB.integer_var + OPC.integer_var; + pointer = OPB(int) + OPC(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); } ptr = pr->pr_globals + pointer; - VectorCopy (&OPA.vector_var, &ptr->vector_var); + VectorCopy (&OPA(float), &ptr->vector_var); break; case OP_STOREB_Q: - pointer = OPB.integer_var + OPC.integer_var; + pointer = OPB(int) + OPC(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); } ptr = pr->pr_globals + pointer; - QuatCopy (&OPA.quat_var, &ptr->quat_var); + QuatCopy (&OPA(float), &ptr->quat_var); break; case OP_STOREB_D: - pointer = OPB.integer_var + OPC.integer_var; + pointer = OPB(int) + OPC(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); } ptr = pr->pr_globals + pointer; - *(double *) ptr = OPA_double_var; + *(double *) ptr = OPA(double); break; case OP_STOREBI_F: @@ -1006,36 +997,36 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREBI_FN: case OP_STOREBI_I: case OP_STOREBI_P: - pointer = OPB.integer_var + (short) st->c; + pointer = OPB(int) + (short) st->c; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_integer); } ptr = pr->pr_globals + pointer; - ptr->integer_var = OPA.integer_var; + ptr->integer_var = OPA(int); break; case OP_STOREBI_V: - pointer = OPB.integer_var + (short) st->c; + pointer = OPB(int) + (short) st->c; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); } ptr = pr->pr_globals + pointer; - VectorCopy (&OPA.vector_var, &ptr->vector_var); + VectorCopy (&OPA(float), &ptr->vector_var); break; case OP_STOREBI_Q: - pointer = OPB.integer_var + (short) st->c; + pointer = OPB(int) + (short) st->c; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); } ptr = pr->pr_globals + pointer; - QuatCopy (&OPA.quat_var, &ptr->quat_var); + QuatCopy (&OPA(float), &ptr->quat_var); break; case OP_STOREBI_D: - pointer = OPB.integer_var + (short) st->c; + pointer = OPB(int) + (short) st->c; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); } ptr = pr->pr_globals + pointer; - *(double *) ptr = OPA_double_var; + *(double *) ptr = OPA(double); break; case OP_PUSH_F: @@ -1051,7 +1042,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 1); } - stk->integer_var = OPA.integer_var; + stk->integer_var = OPA(int); *pr->globals.stack = stack; } break; @@ -1062,7 +1053,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 3); } - memcpy (stk, &OPA, 3 * sizeof (OPC)); + memcpy (stk, op_a, 3 * sizeof (*op_c)); *pr->globals.stack = stack; } break; @@ -1073,7 +1064,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 4); } - memcpy (stk, &OPA, 4 * sizeof (OPC)); + memcpy (stk, op_a, 4 * sizeof (*op_c)); *pr->globals.stack = stack; } break; @@ -1089,7 +1080,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pointer_t stack = *pr->globals.stack - 1; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA.integer_var + OPB.integer_var; + pointer = OPA(int) + OPB(int); ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1106,7 +1097,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pointer_t stack = *pr->globals.stack - 3; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA.integer_var + OPB.integer_var; + pointer = OPA(int) + OPB(int); ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1123,7 +1114,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pointer_t stack = *pr->globals.stack - 4; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA.integer_var + OPB.integer_var; + pointer = OPA(int) + OPB(int); ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1147,7 +1138,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pointer_t stack = *pr->globals.stack - 1; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA.integer_var + st->b; + pointer = OPA(int) + st->b; ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1164,7 +1155,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pointer_t stack = *pr->globals.stack - 3; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA.integer_var + st->b; + pointer = OPA(int) + st->b; ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1181,7 +1172,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pointer_t stack = *pr->globals.stack - 4; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA.integer_var + st->b; + pointer = OPA(int) + st->b; ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1207,7 +1198,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 1); } - OPA.integer_var = stk->integer_var; + OPA(int) = stk->integer_var; *pr->globals.stack = stack + 1; } break; @@ -1218,7 +1209,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 3); } - memcpy (&OPA, stk, 3 * sizeof (OPC)); + memcpy (op_a, stk, 3 * sizeof (*op_c)); *pr->globals.stack = stack + 3; } break; @@ -1229,7 +1220,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 4); } - memcpy (&OPA, stk, 4 * sizeof (OPC)); + memcpy (op_a, stk, 4 * sizeof (*op_c)); *pr->globals.stack = stack + 4; } break; @@ -1245,7 +1236,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA.integer_var + OPB.integer_var; + pointer = OPA(int) + OPB(int); ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1262,7 +1253,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA.integer_var + OPB.integer_var; + pointer = OPA(int) + OPB(int); ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1279,7 +1270,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA.integer_var + OPB.integer_var; + pointer = OPA(int) + OPB(int); ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1303,7 +1294,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA.integer_var + st->b; + pointer = OPA(int) + st->b; ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1320,7 +1311,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA.integer_var + st->b; + pointer = OPA(int) + st->b; ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1337,7 +1328,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA.integer_var + st->b; + pointer = OPA(int) + st->b; ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1352,37 +1343,37 @@ pr_exec_quakec (progs_t *pr, int exitdepth) // ================== case OP_IFNOT: - if (!OPA.integer_var) { + if (!OPA(int)) { pr->pr_xstatement += (short)st->b - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; } break; case OP_IF: - if (OPA.integer_var) { + if (OPA(int)) { pr->pr_xstatement += (short)st->b - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; } break; case OP_IFBE: - if (OPA.integer_var <= 0) { + if (OPA(int) <= 0) { pr->pr_xstatement += (short)st->b - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; } break; case OP_IFB: - if (OPA.integer_var < 0) { + if (OPA(int) < 0) { pr->pr_xstatement += (short)st->b - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; } break; case OP_IFAE: - if (OPA.integer_var >= 0) { + if (OPA(int) >= 0) { pr->pr_xstatement += (short)st->b - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; } break; case OP_IFA: - if (OPA.integer_var > 0) { + if (OPA(int) > 0) { pr->pr_xstatement += (short)st->b - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; } @@ -1393,14 +1384,14 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_JUMP: if (pr_boundscheck->int_val - && (OPA.uinteger_var >= pr->progs->numstatements)) { + && (OPA(uint) >= pr->progs->numstatements)) { PR_RunError (pr, "Invalid jump destination"); } - pr->pr_xstatement = OPA.uinteger_var - 1; // offset the st++ + pr->pr_xstatement = OPA(uint) - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; break; case OP_JUMPB: - pointer = st->a + OPB.integer_var; + pointer = st->a + OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_integer); } @@ -1421,12 +1412,12 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_RCALL6: case OP_RCALL7: case OP_RCALL8: - pr->pr_params[1] = &OPC; + pr->pr_params[1] = op_c; goto op_rcall; case OP_RCALL1: pr->pr_params[1] = pr->pr_real_params[1]; op_rcall: - pr->pr_params[0] = &OPB; + pr->pr_params[0] = op_b; pr->pr_argc = st->op - OP_RCALL1 + 1; goto op_call; case OP_CALL0: @@ -1443,17 +1434,17 @@ op_rcall: op_call: pr->pr_xfunction->profile += profile - startprofile; startprofile = profile; - PR_CallFunction (pr, OPA.func_var); + PR_CallFunction (pr, OPA(uint)); st = pr->pr_statements + pr->pr_xstatement; break; case OP_DONE: case OP_RETURN: if (!st->a) memset (&R_INT (pr), 0, - pr->pr_param_size * sizeof (OPA)); - else if (&R_INT (pr) != &OPA.integer_var) - memcpy (&R_INT (pr), &OPA, - pr->pr_param_size * sizeof (OPA)); + pr->pr_param_size * sizeof (*op_a)); + else if (&R_INT (pr) != &OPA(int)) + memcpy (&R_INT (pr), op_a, + pr->pr_param_size * sizeof (*op_a)); // fallthrough case OP_RETURN_V: pr->pr_xfunction->profile += profile - startprofile; @@ -1475,8 +1466,8 @@ op_call: int think = pr->fields.think + self; float time = *pr->globals.time + 0.1; pr->pr_edict_area[nextthink].float_var = time; - pr->pr_edict_area[frame].float_var = OPA.float_var; - pr->pr_edict_area[think].func_var = OPB.func_var; + pr->pr_edict_area[frame].float_var = OPA(float); + pr->pr_edict_area[think].func_var = OPB(uint); } break; case OP_STATE_F: @@ -1485,23 +1476,23 @@ op_call: int nextthink = pr->fields.nextthink + self; int frame = pr->fields.frame + self; int think = pr->fields.think + self; - float time = *pr->globals.time + OPC.float_var; + float time = *pr->globals.time + OPC(float); pr->pr_edict_area[nextthink].float_var = time; - pr->pr_edict_area[frame].float_var = OPA.float_var; - pr->pr_edict_area[think].func_var = OPB.func_var; + pr->pr_edict_area[frame].float_var = OPA(float); + pr->pr_edict_area[think].func_var = OPB(uint); } break; case OP_ADD_I: - OPC.integer_var = OPA.integer_var + OPB.integer_var; + OPC(int) = OPA(int) + OPB(int); break; case OP_SUB_I: - OPC.integer_var = OPA.integer_var - OPB.integer_var; + OPC(int) = OPA(int) - OPB(int); break; case OP_MUL_I: - OPC.integer_var = OPA.integer_var * OPB.integer_var; + OPC(int) = OPA(int) * OPB(int); break; case OP_DIV_I: - OPC.integer_var = OPA.integer_var / OPB.integer_var; + OPC(int) = OPA(int) / OPB(int); break; case OP_MOD_I: { @@ -1510,193 +1501,193 @@ op_call: // -5 mod 3 = 1 // 5 mod -3 = -1 // -5 mod -3 = -2 - int a = OPA.integer_var; - int b = OPB.integer_var; + int a = OPA(int); + int b = OPB(int); int c = a % b; // % is really remainder and so has the same sign rules // as division: -5 % 3 = -2, so need to add b (3 here) // if c's sign is incorrect, but only if c is non-zero int mask = (a ^ b) >> 31; mask &= ~(!!c + 0) + 1; // +0 to convert bool to int (gcc) - OPC.integer_var = c + (mask & b); + OPC(int) = c + (mask & b); } break; case OP_REM_I: - OPC.integer_var = OPA.integer_var % OPB.integer_var; + OPC(int) = OPA(int) % OPB(int); break; case OP_MOD_D: { - double a = OPA_double_var; - double b = OPB_double_var; + double a = OPA(double); + double b = OPB(double); // floating point modulo is so much easier :P - OPC_double_var = a - b * floor (a / b); + OPC(double) = a - b * floor (a / b); } break; case OP_REM_D: { - double a = OPA_double_var; - double b = OPB_double_var; - OPC_double_var = a - b * trunc (a / b); + double a = OPA(double); + double b = OPB(double); + OPC(double) = a - b * trunc (a / b); } break; case OP_MOD_F: { - float a = OPA.float_var; - float b = OPB.float_var; - OPC.float_var = a - b * floorf (a / b); + float a = OPA(float); + float b = OPB(float); + OPC(float) = a - b * floorf (a / b); } break; case OP_REM_F: { - float a = OPA.float_var; - float b = OPB.float_var; - OPC.float_var = a - b * truncf (a / b); + float a = OPA(float); + float b = OPB(float); + OPC(float) = a - b * truncf (a / b); } break; case OP_CONV_IF: - OPC.float_var = OPA.integer_var; + OPC(float) = OPA(int); break; case OP_CONV_FI: - OPC.integer_var = OPA.float_var; + OPC(int) = OPA(float); break; case OP_BITAND_I: - OPC.integer_var = OPA.integer_var & OPB.integer_var; + OPC(int) = OPA(int) & OPB(int); break; case OP_BITOR_I: - OPC.integer_var = OPA.integer_var | OPB.integer_var; + OPC(int) = OPA(int) | OPB(int); break; case OP_BITXOR_I: - OPC.integer_var = OPA.integer_var ^ OPB.integer_var; + OPC(int) = OPA(int) ^ OPB(int); break; case OP_BITNOT_I: - OPC.integer_var = ~OPA.integer_var; + OPC(int) = ~OPA(int); break; case OP_GE_I: case OP_GE_P: - OPC.integer_var = OPA.integer_var >= OPB.integer_var; + OPC(int) = OPA(int) >= OPB(int); break; case OP_GE_U: - OPC.integer_var = OPA.uinteger_var >= OPB.uinteger_var; + OPC(int) = OPA(uint) >= OPB(uint); break; case OP_LE_I: case OP_LE_P: - OPC.integer_var = OPA.integer_var <= OPB.integer_var; + OPC(int) = OPA(int) <= OPB(int); break; case OP_LE_U: - OPC.integer_var = OPA.uinteger_var <= OPB.uinteger_var; + OPC(int) = OPA(uint) <= OPB(uint); break; case OP_GT_I: case OP_GT_P: - OPC.integer_var = OPA.integer_var > OPB.integer_var; + OPC(int) = OPA(int) > OPB(int); break; case OP_GT_U: - OPC.integer_var = OPA.uinteger_var > OPB.uinteger_var; + OPC(int) = OPA(uint) > OPB(uint); break; case OP_LT_I: case OP_LT_P: - OPC.integer_var = OPA.integer_var < OPB.integer_var; + OPC(int) = OPA(int) < OPB(int); break; case OP_LT_U: - OPC.integer_var = OPA.uinteger_var < OPB.uinteger_var; + OPC(int) = OPA(uint) < OPB(uint); break; case OP_AND_I: - OPC.integer_var = OPA.integer_var && OPB.integer_var; + OPC(int) = OPA(int) && OPB(int); break; case OP_OR_I: - OPC.integer_var = OPA.integer_var || OPB.integer_var; + OPC(int) = OPA(int) || OPB(int); break; case OP_NOT_I: case OP_NOT_P: - OPC.integer_var = !OPA.integer_var; + OPC(int) = !OPA(int); break; case OP_EQ_I: case OP_EQ_P: - OPC.integer_var = OPA.integer_var == OPB.integer_var; + OPC(int) = OPA(int) == OPB(int); break; case OP_NE_I: case OP_NE_P: - OPC.integer_var = OPA.integer_var != OPB.integer_var; + OPC(int) = OPA(int) != OPB(int); break; case OP_MOVEI: - memmove (&OPC, &OPA, st->b * 4); + memmove (op_c, op_a, st->b * 4); break; case OP_MOVEP: if (pr_boundscheck->int_val) { - PR_BoundsCheckSize (pr, OPC.integer_var, OPB.uinteger_var); - PR_BoundsCheckSize (pr, OPA.integer_var, OPB.uinteger_var); + PR_BoundsCheckSize (pr, OPC(int), OPB(uint)); + PR_BoundsCheckSize (pr, OPA(int), OPB(uint)); } - memmove (pr->pr_globals + OPC.integer_var, - pr->pr_globals + OPA.integer_var, - OPB.uinteger_var * 4); + memmove (pr->pr_globals + OPC(int), + pr->pr_globals + OPA(int), + OPB(uint) * 4); break; case OP_MOVEPI: if (pr_boundscheck->int_val) { - PR_BoundsCheckSize (pr, OPC.integer_var, st->b); - PR_BoundsCheckSize (pr, OPA.integer_var, st->b); + PR_BoundsCheckSize (pr, OPC(int), st->b); + PR_BoundsCheckSize (pr, OPA(int), st->b); } - memmove (pr->pr_globals + OPC.integer_var, - pr->pr_globals + OPA.integer_var, + memmove (pr->pr_globals + OPC(int), + pr->pr_globals + OPA(int), st->b * 4); break; case OP_MEMSETI: - pr_memset (&OPC, OPA.integer_var, st->b); + pr_memset (op_c, OPA(int), st->b); break; case OP_MEMSETP: if (pr_boundscheck->int_val) { - PR_BoundsCheckSize (pr, OPC.pointer_var, OPB.integer_var); + PR_BoundsCheckSize (pr, OPC(pointer), OPB(int)); } - pr_memset (pr->pr_globals + OPC.pointer_var, OPA.integer_var, - OPB.integer_var); + pr_memset (pr->pr_globals + OPC(pointer), OPA(int), + OPB(int)); break; case OP_MEMSETPI: if (pr_boundscheck->int_val) { - PR_BoundsCheckSize (pr, OPC.pointer_var, st->b); + PR_BoundsCheckSize (pr, OPC(pointer), st->b); } - pr_memset (pr->pr_globals + OPC.pointer_var, OPA.integer_var, + pr_memset (pr->pr_globals + OPC(pointer), OPA(int), st->b); break; case OP_GE_D: - OPC.float_var = OPA_double_var >= OPB_double_var; + OPC(float) = OPA(double) >= OPB(double); break; case OP_LE_D: - OPC.float_var = OPA_double_var <= OPB_double_var; + OPC(float) = OPA(double) <= OPB(double); break; case OP_GT_D: - OPC.float_var = OPA_double_var > OPB_double_var; + OPC(float) = OPA(double) > OPB(double); break; case OP_LT_D: - OPC.float_var = OPA_double_var < OPB_double_var; + OPC(float) = OPA(double) < OPB(double); break; case OP_NOT_D: - OPC.integer_var = (op_a[0].integer_var + OPC(int) = (op_a[0].integer_var || (op_a[1].integer_var & ~0x80000000u)); break; case OP_EQ_D: - OPC.integer_var = OPA_double_var == OPB_double_var; + OPC(int) = OPA(double) == OPB(double); break; case OP_NE_D: - OPC.integer_var = OPA_double_var != OPB_double_var; + OPC(int) = OPA(double) != OPB(double); break; case OP_CONV_ID: - OPC_double_var = OPA.integer_var; + OPC(double) = OPA(int); break; case OP_CONV_DI: - OPC.integer_var = OPA_double_var; + OPC(int) = OPA(double); break; case OP_CONV_FD: - OPC_double_var = OPA.float_var; + OPC(double) = OPA(float); break; case OP_CONV_DF: - OPC.float_var = OPA_double_var; + OPC(float) = OPA(double); break; // LordHavoc: to be enabled when Progs version 7 (or whatever it will be numbered) is finalized /* case OP_BOUNDCHECK: - if (OPA.integer_var < 0 || OPA.integer_var >= st->b) { + if (OPA(int) < 0 || OPA(int) >= st->b) { PR_RunError (pr, "Progs boundcheck failed at line number " "%d, value is < 0 or >= %d", st->b, st->c); } From 0c17c6dc24fa1dc38ee5c61a78b59e40174aa1ee Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 2 Jan 2022 21:06:14 +0900 Subject: [PATCH 015/360] [gamecode] Rename the old opcodes To reflect their basis on v6 progs instructions, they sport the v6p tag where the p is for "plus" due to the QuakeForge extensions. --- include/QF/pr_comp.h | 594 ++++++++++++++-------------- libs/gamecode/pr_debug.c | 4 +- libs/gamecode/pr_exec.c | 600 ++++++++++++++-------------- libs/gamecode/pr_opcode.c | 744 +++++++++++++++++------------------ tools/qfcc/include/opcodes.h | 35 +- tools/qfcc/source/emit.c | 2 +- tools/qfcc/source/opcodes.c | 28 +- 7 files changed, 1004 insertions(+), 1003 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index 971584070..f51ce2693 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -89,355 +89,355 @@ extern const char * const pr_type_name[ev_type_count]; typedef enum { - OP_DONE, - OP_MUL_F, - OP_MUL_V, - OP_MUL_FV, - OP_MUL_VF, - OP_DIV_F, - OP_ADD_F, - OP_ADD_V, - OP_SUB_F, - OP_SUB_V, + OP_DONE_v6p, + OP_MUL_F_v6p, + OP_MUL_V_v6p, + OP_MUL_FV_v6p, + OP_MUL_VF_v6p, + OP_DIV_F_v6p, + OP_ADD_F_v6p, + OP_ADD_V_v6p, + OP_SUB_F_v6p, + OP_SUB_V_v6p, - OP_EQ_F, - OP_EQ_V, - OP_EQ_S, - OP_EQ_E, - OP_EQ_FN, + OP_EQ_F_v6p, + OP_EQ_V_v6p, + OP_EQ_S_v6p, + OP_EQ_E_v6p, + OP_EQ_FN_v6p, - OP_NE_F, - OP_NE_V, - OP_NE_S, - OP_NE_E, - OP_NE_FN, + OP_NE_F_v6p, + OP_NE_V_v6p, + OP_NE_S_v6p, + OP_NE_E_v6p, + OP_NE_FN_v6p, - OP_LE_F, - OP_GE_F, - OP_LT_F, - OP_GT_F, + OP_LE_F_v6p, + OP_GE_F_v6p, + OP_LT_F_v6p, + OP_GT_F_v6p, - OP_LOAD_F, - OP_LOAD_V, - OP_LOAD_S, - OP_LOAD_ENT, - OP_LOAD_FLD, - OP_LOAD_FN, + OP_LOAD_F_v6p, + OP_LOAD_V_v6p, + OP_LOAD_S_v6p, + OP_LOAD_ENT_v6p, + OP_LOAD_FLD_v6p, + OP_LOAD_FN_v6p, - OP_ADDRESS, + OP_ADDRESS_v6p, - OP_STORE_F, - OP_STORE_V, - OP_STORE_S, - OP_STORE_ENT, - OP_STORE_FLD, - OP_STORE_FN, + OP_STORE_F_v6p, + OP_STORE_V_v6p, + OP_STORE_S_v6p, + OP_STORE_ENT_v6p, + OP_STORE_FLD_v6p, + OP_STORE_FN_v6p, - OP_STOREP_F, - OP_STOREP_V, - OP_STOREP_S, - OP_STOREP_ENT, - OP_STOREP_FLD, - OP_STOREP_FN, + OP_STOREP_F_v6p, + OP_STOREP_V_v6p, + OP_STOREP_S_v6p, + OP_STOREP_ENT_v6p, + OP_STOREP_FLD_v6p, + OP_STOREP_FN_v6p, - OP_RETURN, - OP_NOT_F, - OP_NOT_V, - OP_NOT_S, - OP_NOT_ENT, - OP_NOT_FN, - OP_IF, - OP_IFNOT, - OP_CALL0, - OP_CALL1, - OP_CALL2, - OP_CALL3, - OP_CALL4, - OP_CALL5, - OP_CALL6, - OP_CALL7, - OP_CALL8, - OP_STATE, - OP_GOTO, - OP_AND, - OP_OR, + OP_RETURN_v6p, + OP_NOT_F_v6p, + OP_NOT_V_v6p, + OP_NOT_S_v6p, + OP_NOT_ENT_v6p, + OP_NOT_FN_v6p, + OP_IF_v6p, + OP_IFNOT_v6p, + OP_CALL0_v6p, + OP_CALL1_v6p, + OP_CALL2_v6p, + OP_CALL3_v6p, + OP_CALL4_v6p, + OP_CALL5_v6p, + OP_CALL6_v6p, + OP_CALL7_v6p, + OP_CALL8_v6p, + OP_STATE_v6p, + OP_GOTO_v6p, + OP_AND_v6p, + OP_OR_v6p, - OP_BITAND, - OP_BITOR, // end of v6 opcodes + OP_BITAND_v6p, + OP_BITOR_v6p, // end of v6 opcodes - OP_ADD_S, - OP_LE_S, - OP_GE_S, - OP_LT_S, - OP_GT_S, + OP_ADD_S_v6p, + OP_LE_S_v6p, + OP_GE_S_v6p, + OP_LT_S_v6p, + OP_GT_S_v6p, - OP_ADD_I, - OP_SUB_I, - OP_MUL_I, - OP_DIV_I, - OP_BITAND_I, - OP_BITOR_I, - OP_GE_I, - OP_LE_I, - OP_GT_I, - OP_LT_I, - OP_AND_I, - OP_OR_I, - OP_NOT_I, - OP_EQ_I, - OP_NE_I, - OP_STORE_I, - OP_STOREP_I, - OP_LOAD_I, + OP_ADD_I_v6p, + OP_SUB_I_v6p, + OP_MUL_I_v6p, + OP_DIV_I_v6p, + OP_BITAND_I_v6p, + OP_BITOR_I_v6p, + OP_GE_I_v6p, + OP_LE_I_v6p, + OP_GT_I_v6p, + OP_LT_I_v6p, + OP_AND_I_v6p, + OP_OR_I_v6p, + OP_NOT_I_v6p, + OP_EQ_I_v6p, + OP_NE_I_v6p, + OP_STORE_I_v6p, + OP_STOREP_I_v6p, + OP_LOAD_I_v6p, - OP_CONV_IF, - OP_CONV_FI, + OP_CONV_IF_v6p, + OP_CONV_FI_v6p, - OP_BITXOR_F, - OP_BITXOR_I, - OP_BITNOT_F, - OP_BITNOT_I, + OP_BITXOR_F_v6p, + OP_BITXOR_I_v6p, + OP_BITNOT_F_v6p, + OP_BITNOT_I_v6p, - OP_SHL_F, - OP_SHR_F, - OP_SHL_I, - OP_SHR_I, + OP_SHL_F_v6p, + OP_SHR_F_v6p, + OP_SHL_I_v6p, + OP_SHR_I_v6p, - OP_REM_F, - OP_REM_I, + OP_REM_F_v6p, + OP_REM_I_v6p, - OP_LOADB_F, - OP_LOADB_V, - OP_LOADB_S, - OP_LOADB_ENT, - OP_LOADB_FLD, - OP_LOADB_FN, - OP_LOADB_I, - OP_LOADB_P, + OP_LOADB_F_v6p, + OP_LOADB_V_v6p, + OP_LOADB_S_v6p, + OP_LOADB_ENT_v6p, + OP_LOADB_FLD_v6p, + OP_LOADB_FN_v6p, + OP_LOADB_I_v6p, + OP_LOADB_P_v6p, - OP_STOREB_F, - OP_STOREB_V, - OP_STOREB_S, - OP_STOREB_ENT, - OP_STOREB_FLD, - OP_STOREB_FN, - OP_STOREB_I, - OP_STOREB_P, + OP_STOREB_F_v6p, + OP_STOREB_V_v6p, + OP_STOREB_S_v6p, + OP_STOREB_ENT_v6p, + OP_STOREB_FLD_v6p, + OP_STOREB_FN_v6p, + OP_STOREB_I_v6p, + OP_STOREB_P_v6p, - OP_ADDRESS_VOID, - OP_ADDRESS_F, - OP_ADDRESS_V, - OP_ADDRESS_S, - OP_ADDRESS_ENT, - OP_ADDRESS_FLD, - OP_ADDRESS_FN, - OP_ADDRESS_I, - OP_ADDRESS_P, + OP_ADDRESS_VOID_v6p, + OP_ADDRESS_F_v6p, + OP_ADDRESS_V_v6p, + OP_ADDRESS_S_v6p, + OP_ADDRESS_ENT_v6p, + OP_ADDRESS_FLD_v6p, + OP_ADDRESS_FN_v6p, + OP_ADDRESS_I_v6p, + OP_ADDRESS_P_v6p, - OP_LEA, + OP_LEA_v6p, - OP_IFBE, - OP_IFB, - OP_IFAE, - OP_IFA, + OP_IFBE_v6p, + OP_IFB_v6p, + OP_IFAE_v6p, + OP_IFA_v6p, - OP_JUMP, - OP_JUMPB, + OP_JUMP_v6p, + OP_JUMPB_v6p, - OP_LT_U, - OP_GT_U, - OP_LE_U, - OP_GE_U, + OP_LT_U_v6p, + OP_GT_U_v6p, + OP_LE_U_v6p, + OP_GE_U_v6p, - OP_LOADBI_F, - OP_LOADBI_V, - OP_LOADBI_S, - OP_LOADBI_ENT, - OP_LOADBI_FLD, - OP_LOADBI_FN, - OP_LOADBI_I, - OP_LOADBI_P, + OP_LOADBI_F_v6p, + OP_LOADBI_V_v6p, + OP_LOADBI_S_v6p, + OP_LOADBI_ENT_v6p, + OP_LOADBI_FLD_v6p, + OP_LOADBI_FN_v6p, + OP_LOADBI_I_v6p, + OP_LOADBI_P_v6p, - OP_STOREBI_F, - OP_STOREBI_V, - OP_STOREBI_S, - OP_STOREBI_ENT, - OP_STOREBI_FLD, - OP_STOREBI_FN, - OP_STOREBI_I, - OP_STOREBI_P, + OP_STOREBI_F_v6p, + OP_STOREBI_V_v6p, + OP_STOREBI_S_v6p, + OP_STOREBI_ENT_v6p, + OP_STOREBI_FLD_v6p, + OP_STOREBI_FN_v6p, + OP_STOREBI_I_v6p, + OP_STOREBI_P_v6p, - OP_LEAI, + OP_LEAI_v6p, - OP_LOAD_P, - OP_STORE_P, - OP_STOREP_P, - OP_NOT_P, - OP_EQ_P, - OP_NE_P, - OP_LE_P, - OP_GE_P, - OP_LT_P, - OP_GT_P, + OP_LOAD_P_v6p, + OP_STORE_P_v6p, + OP_STOREP_P_v6p, + OP_NOT_P_v6p, + OP_EQ_P_v6p, + OP_NE_P_v6p, + OP_LE_P_v6p, + OP_GE_P_v6p, + OP_LT_P_v6p, + OP_GT_P_v6p, - OP_MOVEI, - OP_MOVEP, - OP_MOVEPI, + OP_MOVEI_v6p, + OP_MOVEP_v6p, + OP_MOVEPI_v6p, - OP_SHR_U, + OP_SHR_U_v6p, - OP_STATE_F, + OP_STATE_F_v6p, - OP_ADD_Q, - OP_SUB_Q, - OP_MUL_Q, - OP_MUL_QF, - OP_MUL_FQ, - OP_MUL_QV, - OP_CONJ_Q, - OP_NOT_Q, - OP_EQ_Q, - OP_NE_Q, - OP_STORE_Q, - OP_STOREB_Q, - OP_STOREBI_Q, - OP_STOREP_Q, - OP_LOAD_Q, - OP_LOADB_Q, - OP_LOADBI_Q, - OP_ADDRESS_Q, + OP_ADD_Q_v6p, + OP_SUB_Q_v6p, + OP_MUL_Q_v6p, + OP_MUL_QF_v6p, + OP_MUL_FQ_v6p, + OP_MUL_QV_v6p, + OP_CONJ_Q_v6p, + OP_NOT_Q_v6p, + OP_EQ_Q_v6p, + OP_NE_Q_v6p, + OP_STORE_Q_v6p, + OP_STOREB_Q_v6p, + OP_STOREBI_Q_v6p, + OP_STOREP_Q_v6p, + OP_LOAD_Q_v6p, + OP_LOADB_Q_v6p, + OP_LOADBI_Q_v6p, + OP_ADDRESS_Q_v6p, - OP_RCALL0, - OP_RCALL1, - OP_RCALL2, - OP_RCALL3, - OP_RCALL4, - OP_RCALL5, - OP_RCALL6, - OP_RCALL7, - OP_RCALL8, + OP_RCALL0_v6p, + OP_RCALL1_v6p, + OP_RCALL2_v6p, + OP_RCALL3_v6p, + OP_RCALL4_v6p, + OP_RCALL5_v6p, + OP_RCALL6_v6p, + OP_RCALL7_v6p, + OP_RCALL8_v6p, - OP_RETURN_V, + OP_RETURN_V_v6p, - OP_PUSH_S, - OP_PUSH_F, - OP_PUSH_V, - OP_PUSH_ENT, - OP_PUSH_FLD, - OP_PUSH_FN, - OP_PUSH_P, - OP_PUSH_Q, - OP_PUSH_I, - OP_PUSH_D, + OP_PUSH_S_v6p, + OP_PUSH_F_v6p, + OP_PUSH_V_v6p, + OP_PUSH_ENT_v6p, + OP_PUSH_FLD_v6p, + OP_PUSH_FN_v6p, + OP_PUSH_P_v6p, + OP_PUSH_Q_v6p, + OP_PUSH_I_v6p, + OP_PUSH_D_v6p, - OP_PUSHB_S, - OP_PUSHB_F, - OP_PUSHB_V, - OP_PUSHB_ENT, - OP_PUSHB_FLD, - OP_PUSHB_FN, - OP_PUSHB_P, - OP_PUSHB_Q, - OP_PUSHB_I, - OP_PUSHB_D, + OP_PUSHB_S_v6p, + OP_PUSHB_F_v6p, + OP_PUSHB_V_v6p, + OP_PUSHB_ENT_v6p, + OP_PUSHB_FLD_v6p, + OP_PUSHB_FN_v6p, + OP_PUSHB_P_v6p, + OP_PUSHB_Q_v6p, + OP_PUSHB_I_v6p, + OP_PUSHB_D_v6p, - OP_PUSHBI_S, - OP_PUSHBI_F, - OP_PUSHBI_V, - OP_PUSHBI_ENT, - OP_PUSHBI_FLD, - OP_PUSHBI_FN, - OP_PUSHBI_P, - OP_PUSHBI_Q, - OP_PUSHBI_I, - OP_PUSHBI_D, + OP_PUSHBI_S_v6p, + OP_PUSHBI_F_v6p, + OP_PUSHBI_V_v6p, + OP_PUSHBI_ENT_v6p, + OP_PUSHBI_FLD_v6p, + OP_PUSHBI_FN_v6p, + OP_PUSHBI_P_v6p, + OP_PUSHBI_Q_v6p, + OP_PUSHBI_I_v6p, + OP_PUSHBI_D_v6p, - OP_POP_S, - OP_POP_F, - OP_POP_V, - OP_POP_ENT, - OP_POP_FLD, - OP_POP_FN, - OP_POP_P, - OP_POP_Q, - OP_POP_I, - OP_POP_D, + OP_POP_S_v6p, + OP_POP_F_v6p, + OP_POP_V_v6p, + OP_POP_ENT_v6p, + OP_POP_FLD_v6p, + OP_POP_FN_v6p, + OP_POP_P_v6p, + OP_POP_Q_v6p, + OP_POP_I_v6p, + OP_POP_D_v6p, - OP_POPB_S, - OP_POPB_F, - OP_POPB_V, - OP_POPB_ENT, - OP_POPB_FLD, - OP_POPB_FN, - OP_POPB_P, - OP_POPB_Q, - OP_POPB_I, - OP_POPB_D, + OP_POPB_S_v6p, + OP_POPB_F_v6p, + OP_POPB_V_v6p, + OP_POPB_ENT_v6p, + OP_POPB_FLD_v6p, + OP_POPB_FN_v6p, + OP_POPB_P_v6p, + OP_POPB_Q_v6p, + OP_POPB_I_v6p, + OP_POPB_D_v6p, - OP_POPBI_S, - OP_POPBI_F, - OP_POPBI_V, - OP_POPBI_ENT, - OP_POPBI_FLD, - OP_POPBI_FN, - OP_POPBI_P, - OP_POPBI_Q, - OP_POPBI_I, - OP_POPBI_D, + OP_POPBI_S_v6p, + OP_POPBI_F_v6p, + OP_POPBI_V_v6p, + OP_POPBI_ENT_v6p, + OP_POPBI_FLD_v6p, + OP_POPBI_FN_v6p, + OP_POPBI_P_v6p, + OP_POPBI_Q_v6p, + OP_POPBI_I_v6p, + OP_POPBI_D_v6p, - OP_ADD_D, - OP_SUB_D, - OP_MUL_D, - OP_MUL_QD, - OP_MUL_DQ, - OP_MUL_VD, - OP_MUL_DV, - OP_DIV_D, - OP_REM_D, - OP_GE_D, - OP_LE_D, - OP_GT_D, - OP_LT_D, - OP_NOT_D, - OP_EQ_D, - OP_NE_D, - OP_CONV_FD, - OP_CONV_DF, - OP_CONV_ID, - OP_CONV_DI, - OP_STORE_D, - OP_STOREB_D, - OP_STOREBI_D, - OP_STOREP_D, - OP_LOAD_D, - OP_LOADB_D, - OP_LOADBI_D, - OP_ADDRESS_D, + OP_ADD_D_v6p, + OP_SUB_D_v6p, + OP_MUL_D_v6p, + OP_MUL_QD_v6p, + OP_MUL_DQ_v6p, + OP_MUL_VD_v6p, + OP_MUL_DV_v6p, + OP_DIV_D_v6p, + OP_REM_D_v6p, + OP_GE_D_v6p, + OP_LE_D_v6p, + OP_GT_D_v6p, + OP_LT_D_v6p, + OP_NOT_D_v6p, + OP_EQ_D_v6p, + OP_NE_D_v6p, + OP_CONV_FD_v6p, + OP_CONV_DF_v6p, + OP_CONV_ID_v6p, + OP_CONV_DI_v6p, + OP_STORE_D_v6p, + OP_STOREB_D_v6p, + OP_STOREBI_D_v6p, + OP_STOREP_D_v6p, + OP_LOAD_D_v6p, + OP_LOADB_D_v6p, + OP_LOADBI_D_v6p, + OP_ADDRESS_D_v6p, - OP_MOD_I, - OP_MOD_F, - OP_MOD_D, + OP_MOD_I_v6p, + OP_MOD_F_v6p, + OP_MOD_D_v6p, - OP_MEMSETI, - OP_MEMSETP, - OP_MEMSETPI, -} pr_opcode_e; + OP_MEMSETI_v6p, + OP_MEMSETP_v6p, + OP_MEMSETPI_v6p, +} pr_opcode_v6p_e; #define OP_BREAK 0x8000 -typedef struct opcode_s { +typedef struct v6p_opcode_s { const char *name; const char *opname; etype_t type_a, type_b, type_c; unsigned int min_version; const char *fmt; -} opcode_t; +} v6p_opcode_t; -extern const opcode_t pr_opcodes[]; -const opcode_t *PR_Opcode (pr_short_t opcode) __attribute__((const)); +extern const v6p_opcode_t pr_v6p_opcodes[]; +const v6p_opcode_t *PR_v6p_Opcode (pr_ushort_t opcode) __attribute__((const)); void PR_Opcode_Init (void); // idempotent typedef struct dstatement_s { - pr_opcode_e op:16; + pr_opcode_v6p_e op:16; pr_ushort_t a,b,c; } GCC_STRUCT dstatement_t; diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index a720a863d..9b8d11fde 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -1482,7 +1482,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) int addr = s - pr->pr_statements; int dump_code = contents & 2; const char *fmt; - const opcode_t *op; + const v6p_opcode_t *op; dfunction_t *call_func = 0; pr_def_t *parm_def = 0; pr_auxfunction_t *aux_func = 0; @@ -1508,7 +1508,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) return; } - op = PR_Opcode (s->op); + op = PR_v6p_Opcode (s->op); if (!op) { Sys_Printf ("%sUnknown instruction %d\n", res->line->str, s->op); return; diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index fa226a417..ae6b3df4e 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -355,23 +355,23 @@ signal_hook (int sig, void *data) op_c = pr->pr_globals + st->c; switch (st->op) { - case OP_DIV_F: + case OP_DIV_F_v6p: if ((OPA(int) & 0x80000000) ^ (OPB(int) & 0x80000000)) OPC(int) = 0xff7fffff; else OPC(int) = 0x7f7fffff; return 1; - case OP_DIV_I: + case OP_DIV_I_v6p: if (OPA(int) & 0x80000000) OPC(int) = -0x80000000; else OPC(int) = 0x7fffffff; return 1; - case OP_MOD_I: - case OP_MOD_F: - case OP_REM_I: - case OP_REM_F: + case OP_MOD_I_v6p: + case OP_MOD_F_v6p: + case OP_REM_I_v6p: + case OP_REM_F_v6p: OPC(int) = 0x00000000; return 1; default: @@ -481,50 +481,50 @@ pr_exec_quakec (progs_t *pr, int exitdepth) } } - pr_opcode_e op = st->op & ~OP_BREAK; + pr_opcode_v6p_e op = st->op & ~OP_BREAK; switch (op) { - case OP_ADD_D: + case OP_ADD_D_v6p: OPC(double) = OPA(double) + OPB(double); break; - case OP_ADD_F: + case OP_ADD_F_v6p: OPC(float) = OPA(float) + OPB(float); break; - case OP_ADD_V: + case OP_ADD_V_v6p: VectorAdd (&OPA(float), &OPB(float), &OPC(float)); break; - case OP_ADD_Q: + case OP_ADD_Q_v6p: QuatAdd (&OPA(float), &OPB(float), &OPC(float)); break; - case OP_ADD_S: + case OP_ADD_S_v6p: OPC(string) = PR_CatStrings (pr, PR_GetString (pr, OPA(string)), PR_GetString (pr, OPB(string))); break; - case OP_SUB_D: + case OP_SUB_D_v6p: OPC(double) = OPA(double) - OPB(double); break; - case OP_SUB_F: + case OP_SUB_F_v6p: OPC(float) = OPA(float) - OPB(float); break; - case OP_SUB_V: + case OP_SUB_V_v6p: VectorSubtract (&OPA(float), &OPB(float), &OPC(float)); break; - case OP_SUB_Q: + case OP_SUB_Q_v6p: QuatSubtract (&OPA(float), &OPB(float), &OPC(float)); break; - case OP_MUL_D: + case OP_MUL_D_v6p: OPC(double) = OPA(double) * OPB(double); break; - case OP_MUL_F: + case OP_MUL_F_v6p: OPC(float) = OPA(float) * OPB(float); break; - case OP_MUL_V: + case OP_MUL_V_v6p: OPC(float) = DotProduct (&OPA(float), &OPB(float)); break; - case OP_MUL_DV: + case OP_MUL_DV_v6p: { // avoid issues with the likes of x = x.x * x; // makes for faster code, too @@ -532,7 +532,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) VectorScale (&OPB(float), scale, &OPC(float)); } break; - case OP_MUL_VD: + case OP_MUL_VD_v6p: { // avoid issues with the likes of x = x * x.x; // makes for faster code, too @@ -540,7 +540,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) VectorScale (&OPA(float), scale, &OPC(float)); } break; - case OP_MUL_FV: + case OP_MUL_FV_v6p: { // avoid issues with the likes of x = x.x * x; // makes for faster code, too @@ -548,7 +548,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) VectorScale (&OPB(float), scale, &OPC(float)); } break; - case OP_MUL_VF: + case OP_MUL_VF_v6p: { // avoid issues with the likes of x = x * x.x; // makes for faster code, too @@ -556,13 +556,13 @@ pr_exec_quakec (progs_t *pr, int exitdepth) VectorScale (&OPA(float), scale, &OPC(float)); } break; - case OP_MUL_Q: + case OP_MUL_Q_v6p: QuatMult (&OPA(float), &OPB(float), &OPC(float)); break; - case OP_MUL_QV: + case OP_MUL_QV_v6p: QuatMultVec (&OPA(float), &OPB(float), &OPC(float)); break; - case OP_MUL_DQ: + case OP_MUL_DQ_v6p: { // avoid issues with the likes of x = x.s * x; // makes for faster code, too @@ -570,7 +570,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) QuatScale (&OPB(float), scale, &OPC(float)); } break; - case OP_MUL_QD: + case OP_MUL_QD_v6p: { // avoid issues with the likes of x = x * x.s; // makes for faster code, too @@ -578,7 +578,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) QuatScale (&OPA(float), scale, &OPC(float)); } break; - case OP_MUL_FQ: + case OP_MUL_FQ_v6p: { // avoid issues with the likes of x = x.s * x; // makes for faster code, too @@ -586,7 +586,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) QuatScale (&OPB(float), scale, &OPC(float)); } break; - case OP_MUL_QF: + case OP_MUL_QF_v6p: { // avoid issues with the likes of x = x * x.s; // makes for faster code, too @@ -594,160 +594,160 @@ pr_exec_quakec (progs_t *pr, int exitdepth) QuatScale (&OPA(float), scale, &OPC(float)); } break; - case OP_CONJ_Q: + case OP_CONJ_Q_v6p: QuatConj (&OPA(float), &OPC(float)); break; - case OP_DIV_D: + case OP_DIV_D_v6p: OPC(double) = OPA(double) / OPB(double); break; - case OP_DIV_F: + case OP_DIV_F_v6p: OPC(float) = OPA(float) / OPB(float); break; - case OP_BITAND: + case OP_BITAND_v6p: OPC(float) = (int) OPA(float) & (int) OPB(float); break; - case OP_BITOR: + case OP_BITOR_v6p: OPC(float) = (int) OPA(float) | (int) OPB(float); break; - case OP_BITXOR_F: + case OP_BITXOR_F_v6p: OPC(float) = (int) OPA(float) ^ (int) OPB(float); break; - case OP_BITNOT_F: + case OP_BITNOT_F_v6p: OPC(float) = ~ (int) OPA(float); break; - case OP_SHL_F: + case OP_SHL_F_v6p: OPC(float) = (int) OPA(float) << (int) OPB(float); break; - case OP_SHR_F: + case OP_SHR_F_v6p: OPC(float) = (int) OPA(float) >> (int) OPB(float); break; - case OP_SHL_I: + case OP_SHL_I_v6p: OPC(int) = OPA(int) << OPB(int); break; - case OP_SHR_I: + case OP_SHR_I_v6p: OPC(int) = OPA(int) >> OPB(int); break; - case OP_SHR_U: + case OP_SHR_U_v6p: OPC(uint) = OPA(uint) >> OPB(int); break; - case OP_GE_F: + case OP_GE_F_v6p: OPC(float) = OPA(float) >= OPB(float); break; - case OP_LE_F: + case OP_LE_F_v6p: OPC(float) = OPA(float) <= OPB(float); break; - case OP_GT_F: + case OP_GT_F_v6p: OPC(float) = OPA(float) > OPB(float); break; - case OP_LT_F: + case OP_LT_F_v6p: OPC(float) = OPA(float) < OPB(float); break; - case OP_AND: // OPA and OPB have to be float for -0.0 + case OP_AND_v6p: // OPA and OPB have to be float for -0.0 OPC(int) = FNZ (OPA(uint)) && FNZ (OPB(uint)); break; - case OP_OR: // OPA and OPB have to be float for -0.0 + case OP_OR_v6p: // OPA and OPB have to be float for -0.0 OPC(int) = FNZ (OPA(uint)) || FNZ (OPB(uint)); break; - case OP_NOT_F: + case OP_NOT_F_v6p: OPC(int) = !FNZ (OPA(uint)); break; - case OP_NOT_V: + case OP_NOT_V_v6p: OPC(int) = VectorIsZero (&OPA(float)); break; - case OP_NOT_Q: + case OP_NOT_Q_v6p: OPC(int) = QuatIsZero (&OPA(float)); break; - case OP_NOT_S: + case OP_NOT_S_v6p: OPC(int) = !OPA(string) || !*PR_GetString (pr, OPA(string)); break; - case OP_NOT_FN: + case OP_NOT_FN_v6p: OPC(int) = !OPA(uint); break; - case OP_NOT_ENT: + case OP_NOT_ENT_v6p: OPC(int) = !OPA(uint); break; - case OP_EQ_F: + case OP_EQ_F_v6p: OPC(int) = OPA(float) == OPB(float); break; - case OP_EQ_V: + case OP_EQ_V_v6p: OPC(int) = VectorCompare (&OPA(float), &OPB(float)); break; - case OP_EQ_Q: + case OP_EQ_Q_v6p: OPC(int) = QuatCompare (&OPA(float), &OPB(float)); break; - case OP_EQ_E: + case OP_EQ_E_v6p: OPC(int) = OPA(int) == OPB(int); break; - case OP_EQ_FN: + case OP_EQ_FN_v6p: OPC(int) = OPA(uint) == OPB(uint); break; - case OP_NE_F: + case OP_NE_F_v6p: OPC(int) = OPA(float) != OPB(float); break; - case OP_NE_V: + case OP_NE_V_v6p: OPC(int) = !VectorCompare (&OPA(float), &OPB(float)); break; - case OP_NE_Q: + case OP_NE_Q_v6p: OPC(int) = !QuatCompare (&OPA(float), &OPB(float)); break; - case OP_LE_S: - case OP_GE_S: - case OP_LT_S: - case OP_GT_S: - case OP_NE_S: - case OP_EQ_S: + case OP_LE_S_v6p: + case OP_GE_S_v6p: + case OP_LT_S_v6p: + case OP_GT_S_v6p: + case OP_NE_S_v6p: + case OP_EQ_S_v6p: { int cmp = strcmp (PR_GetString (pr, OPA(string)), PR_GetString (pr, OPB(string))); switch (st->op) { - case OP_LE_S: cmp = (cmp <= 0); break; - case OP_GE_S: cmp = (cmp >= 0); break; - case OP_LT_S: cmp = (cmp < 0); break; - case OP_GT_S: cmp = (cmp > 0); break; - case OP_NE_S: break; - case OP_EQ_S: cmp = !cmp; break; + case OP_LE_S_v6p: cmp = (cmp <= 0); break; + case OP_GE_S_v6p: cmp = (cmp >= 0); break; + case OP_LT_S_v6p: cmp = (cmp < 0); break; + case OP_GT_S_v6p: cmp = (cmp > 0); break; + case OP_NE_S_v6p: break; + case OP_EQ_S_v6p: cmp = !cmp; break; default: break; } OPC(int) = cmp; } break; - case OP_NE_E: + case OP_NE_E_v6p: OPC(int) = OPA(int) != OPB(int); break; - case OP_NE_FN: + case OP_NE_FN_v6p: OPC(int) = OPA(uint) != OPB(uint); break; // ================== - case OP_STORE_F: - case OP_STORE_ENT: - case OP_STORE_FLD: // integers - case OP_STORE_S: - case OP_STORE_FN: // pointers - case OP_STORE_I: - case OP_STORE_P: + case OP_STORE_F_v6p: + case OP_STORE_ENT_v6p: + case OP_STORE_FLD_v6p: // integers + case OP_STORE_S_v6p: + case OP_STORE_FN_v6p: // pointers + case OP_STORE_I_v6p: + case OP_STORE_P_v6p: OPB(int) = OPA(int); break; - case OP_STORE_V: + case OP_STORE_V_v6p: VectorCopy (&OPA(float), &OPB(float)); break; - case OP_STORE_Q: + case OP_STORE_Q_v6p: QuatCopy (&OPA(float), &OPB(float)); break; - case OP_STORE_D: + case OP_STORE_D_v6p: OPB(double) = OPA(double); break; - case OP_STOREP_F: - case OP_STOREP_ENT: - case OP_STOREP_FLD: // integers - case OP_STOREP_S: - case OP_STOREP_FN: // pointers - case OP_STOREP_I: - case OP_STOREP_P: + case OP_STOREP_F_v6p: + case OP_STOREP_ENT_v6p: + case OP_STOREP_FLD_v6p: // integers + case OP_STOREP_S_v6p: + case OP_STOREP_FN_v6p: // pointers + case OP_STOREP_I_v6p: + case OP_STOREP_P_v6p: pointer = OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_integer); @@ -755,7 +755,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; ptr->integer_var = OPA(int); break; - case OP_STOREP_V: + case OP_STOREP_V_v6p: pointer = OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); @@ -763,7 +763,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; VectorCopy (&OPA(float), &ptr->vector_var); break; - case OP_STOREP_Q: + case OP_STOREP_Q_v6p: pointer = OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); @@ -771,7 +771,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; QuatCopy (&OPA(float), &ptr->quat_var); break; - case OP_STOREP_D: + case OP_STOREP_D_v6p: pointer = OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_double); @@ -780,7 +780,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *(double *) ptr = OPA(double); break; - case OP_ADDRESS: + case OP_ADDRESS_v6p: if (pr_boundscheck->int_val) { if (OPA(uint) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to address an out " @@ -794,27 +794,27 @@ pr_exec_quakec (progs_t *pr, int exitdepth) fldofs = OPA(uint) + OPB(int); OPC(int) = &pr->pr_edict_area[fldofs] - pr->pr_globals; break; - case OP_ADDRESS_VOID: - case OP_ADDRESS_F: - case OP_ADDRESS_V: - case OP_ADDRESS_Q: - case OP_ADDRESS_S: - case OP_ADDRESS_ENT: - case OP_ADDRESS_FLD: - case OP_ADDRESS_FN: - case OP_ADDRESS_I: - case OP_ADDRESS_P: - case OP_ADDRESS_D: + case OP_ADDRESS_VOID_v6p: + case OP_ADDRESS_F_v6p: + case OP_ADDRESS_V_v6p: + case OP_ADDRESS_Q_v6p: + case OP_ADDRESS_S_v6p: + case OP_ADDRESS_ENT_v6p: + case OP_ADDRESS_FLD_v6p: + case OP_ADDRESS_FN_v6p: + case OP_ADDRESS_I_v6p: + case OP_ADDRESS_P_v6p: + case OP_ADDRESS_D_v6p: OPC(int) = st->a; break; - case OP_LOAD_F: - case OP_LOAD_FLD: - case OP_LOAD_ENT: - case OP_LOAD_S: - case OP_LOAD_FN: - case OP_LOAD_I: - case OP_LOAD_P: + case OP_LOAD_F_v6p: + case OP_LOAD_FLD_v6p: + case OP_LOAD_ENT_v6p: + case OP_LOAD_S_v6p: + case OP_LOAD_FN_v6p: + case OP_LOAD_I_v6p: + case OP_LOAD_P_v6p: if (pr_boundscheck->int_val) { if (OPA(uint) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to read an out of " @@ -826,7 +826,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) fldofs = OPA(uint) + OPB(int); OPC(int) = pr->pr_edict_area[fldofs].integer_var; break; - case OP_LOAD_V: + case OP_LOAD_V_v6p: if (pr_boundscheck->int_val) { if (OPA(uint) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to read an out of " @@ -838,7 +838,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) fldofs = OPA(uint) + OPB(int); memcpy (op_c, &pr->pr_edict_area[fldofs], 3 * sizeof (*op_c)); break; - case OP_LOAD_Q: + case OP_LOAD_Q_v6p: if (pr_boundscheck->int_val) { if (OPA(uint) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to read an out of " @@ -850,7 +850,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) fldofs = OPA(uint) + OPB(int); memcpy (op_c, &pr->pr_edict_area[fldofs], 4 * sizeof (*op_c)); break; - case OP_LOAD_D: + case OP_LOAD_D_v6p: if (pr_boundscheck->int_val) { if (OPA(uint) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to read an out of " @@ -863,13 +863,13 @@ pr_exec_quakec (progs_t *pr, int exitdepth) memcpy (op_c, &pr->pr_edict_area[fldofs], sizeof (double)); break; - case OP_LOADB_F: - case OP_LOADB_S: - case OP_LOADB_ENT: - case OP_LOADB_FLD: - case OP_LOADB_FN: - case OP_LOADB_I: - case OP_LOADB_P: + case OP_LOADB_F_v6p: + case OP_LOADB_S_v6p: + case OP_LOADB_ENT_v6p: + case OP_LOADB_FLD_v6p: + case OP_LOADB_FN_v6p: + case OP_LOADB_I_v6p: + case OP_LOADB_P_v6p: pointer = OPA(int) + OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_integer); @@ -877,7 +877,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; OPC(int) = ptr->integer_var; break; - case OP_LOADB_V: + case OP_LOADB_V_v6p: pointer = OPA(int) + OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); @@ -885,7 +885,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; VectorCopy (&ptr->vector_var, &OPC(float)); break; - case OP_LOADB_Q: + case OP_LOADB_Q_v6p: pointer = OPA(int) + OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); @@ -893,7 +893,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; QuatCopy (&ptr->quat_var, &OPC(float)); break; - case OP_LOADB_D: + case OP_LOADB_D_v6p: pointer = OPA(int) + OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_double); @@ -902,13 +902,13 @@ pr_exec_quakec (progs_t *pr, int exitdepth) OPC(double) = *(double *) ptr; break; - case OP_LOADBI_F: - case OP_LOADBI_S: - case OP_LOADBI_ENT: - case OP_LOADBI_FLD: - case OP_LOADBI_FN: - case OP_LOADBI_I: - case OP_LOADBI_P: + case OP_LOADBI_F_v6p: + case OP_LOADBI_S_v6p: + case OP_LOADBI_ENT_v6p: + case OP_LOADBI_FLD_v6p: + case OP_LOADBI_FN_v6p: + case OP_LOADBI_I_v6p: + case OP_LOADBI_P_v6p: pointer = OPA(int) + (short) st->b; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_integer); @@ -916,7 +916,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; OPC(int) = ptr->integer_var; break; - case OP_LOADBI_V: + case OP_LOADBI_V_v6p: pointer = OPA(int) + (short) st->b; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); @@ -924,7 +924,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; VectorCopy (&ptr->vector_var, &OPC(float)); break; - case OP_LOADBI_Q: + case OP_LOADBI_Q_v6p: pointer = OPA(int) + (short) st->b; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); @@ -932,7 +932,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; QuatCopy (&ptr->quat_var, &OPC(float)); break; - case OP_LOADBI_D: + case OP_LOADBI_D_v6p: pointer = OPA(int) + (short) st->b; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); @@ -941,23 +941,23 @@ pr_exec_quakec (progs_t *pr, int exitdepth) OPC(double) = *(double *) ptr; break; - case OP_LEA: + case OP_LEA_v6p: pointer = OPA(int) + OPB(int); OPC(int) = pointer; break; - case OP_LEAI: + case OP_LEAI_v6p: pointer = OPA(int) + (short) st->b; OPC(int) = pointer; break; - case OP_STOREB_F: - case OP_STOREB_S: - case OP_STOREB_ENT: - case OP_STOREB_FLD: - case OP_STOREB_FN: - case OP_STOREB_I: - case OP_STOREB_P: + case OP_STOREB_F_v6p: + case OP_STOREB_S_v6p: + case OP_STOREB_ENT_v6p: + case OP_STOREB_FLD_v6p: + case OP_STOREB_FN_v6p: + case OP_STOREB_I_v6p: + case OP_STOREB_P_v6p: pointer = OPB(int) + OPC(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_integer); @@ -965,7 +965,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; ptr->integer_var = OPA(int); break; - case OP_STOREB_V: + case OP_STOREB_V_v6p: pointer = OPB(int) + OPC(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); @@ -973,7 +973,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; VectorCopy (&OPA(float), &ptr->vector_var); break; - case OP_STOREB_Q: + case OP_STOREB_Q_v6p: pointer = OPB(int) + OPC(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); @@ -981,7 +981,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; QuatCopy (&OPA(float), &ptr->quat_var); break; - case OP_STOREB_D: + case OP_STOREB_D_v6p: pointer = OPB(int) + OPC(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); @@ -990,13 +990,13 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *(double *) ptr = OPA(double); break; - case OP_STOREBI_F: - case OP_STOREBI_S: - case OP_STOREBI_ENT: - case OP_STOREBI_FLD: - case OP_STOREBI_FN: - case OP_STOREBI_I: - case OP_STOREBI_P: + case OP_STOREBI_F_v6p: + case OP_STOREBI_S_v6p: + case OP_STOREBI_ENT_v6p: + case OP_STOREBI_FLD_v6p: + case OP_STOREBI_FN_v6p: + case OP_STOREBI_I_v6p: + case OP_STOREBI_P_v6p: pointer = OPB(int) + (short) st->c; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_integer); @@ -1004,7 +1004,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; ptr->integer_var = OPA(int); break; - case OP_STOREBI_V: + case OP_STOREBI_V_v6p: pointer = OPB(int) + (short) st->c; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); @@ -1012,7 +1012,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; VectorCopy (&OPA(float), &ptr->vector_var); break; - case OP_STOREBI_Q: + case OP_STOREBI_Q_v6p: pointer = OPB(int) + (short) st->c; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); @@ -1020,7 +1020,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; QuatCopy (&OPA(float), &ptr->quat_var); break; - case OP_STOREBI_D: + case OP_STOREBI_D_v6p: pointer = OPB(int) + (short) st->c; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quat); @@ -1029,13 +1029,13 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *(double *) ptr = OPA(double); break; - case OP_PUSH_F: - case OP_PUSH_FLD: - case OP_PUSH_ENT: - case OP_PUSH_S: - case OP_PUSH_FN: - case OP_PUSH_I: - case OP_PUSH_P: + case OP_PUSH_F_v6p: + case OP_PUSH_FLD_v6p: + case OP_PUSH_ENT_v6p: + case OP_PUSH_S_v6p: + case OP_PUSH_FN_v6p: + case OP_PUSH_I_v6p: + case OP_PUSH_P_v6p: { pointer_t stack = *pr->globals.stack - 1; pr_type_t *stk = pr->pr_globals + stack; @@ -1046,7 +1046,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *pr->globals.stack = stack; } break; - case OP_PUSH_V: + case OP_PUSH_V_v6p: { pointer_t stack = *pr->globals.stack - 3; pr_type_t *stk = pr->pr_globals + stack; @@ -1057,7 +1057,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *pr->globals.stack = stack; } break; - case OP_PUSH_Q: + case OP_PUSH_Q_v6p: { pointer_t stack = *pr->globals.stack - 4; pr_type_t *stk = pr->pr_globals + stack; @@ -1069,13 +1069,13 @@ pr_exec_quakec (progs_t *pr, int exitdepth) } break; - case OP_PUSHB_F: - case OP_PUSHB_S: - case OP_PUSHB_ENT: - case OP_PUSHB_FLD: - case OP_PUSHB_FN: - case OP_PUSHB_I: - case OP_PUSHB_P: + case OP_PUSHB_F_v6p: + case OP_PUSHB_S_v6p: + case OP_PUSHB_ENT_v6p: + case OP_PUSHB_FLD_v6p: + case OP_PUSHB_FN_v6p: + case OP_PUSHB_I_v6p: + case OP_PUSHB_P_v6p: { pointer_t stack = *pr->globals.stack - 1; pr_type_t *stk = pr->pr_globals + stack; @@ -1092,7 +1092,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *pr->globals.stack = stack; } break; - case OP_PUSHB_V: + case OP_PUSHB_V_v6p: { pointer_t stack = *pr->globals.stack - 3; pr_type_t *stk = pr->pr_globals + stack; @@ -1109,7 +1109,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *pr->globals.stack = stack; } break; - case OP_PUSHB_Q: + case OP_PUSHB_Q_v6p: { pointer_t stack = *pr->globals.stack - 4; pr_type_t *stk = pr->pr_globals + stack; @@ -1127,13 +1127,13 @@ pr_exec_quakec (progs_t *pr, int exitdepth) } break; - case OP_PUSHBI_F: - case OP_PUSHBI_S: - case OP_PUSHBI_ENT: - case OP_PUSHBI_FLD: - case OP_PUSHBI_FN: - case OP_PUSHBI_I: - case OP_PUSHBI_P: + case OP_PUSHBI_F_v6p: + case OP_PUSHBI_S_v6p: + case OP_PUSHBI_ENT_v6p: + case OP_PUSHBI_FLD_v6p: + case OP_PUSHBI_FN_v6p: + case OP_PUSHBI_I_v6p: + case OP_PUSHBI_P_v6p: { pointer_t stack = *pr->globals.stack - 1; pr_type_t *stk = pr->pr_globals + stack; @@ -1150,7 +1150,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *pr->globals.stack = stack; } break; - case OP_PUSHBI_V: + case OP_PUSHBI_V_v6p: { pointer_t stack = *pr->globals.stack - 3; pr_type_t *stk = pr->pr_globals + stack; @@ -1167,7 +1167,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *pr->globals.stack = stack; } break; - case OP_PUSHBI_Q: + case OP_PUSHBI_Q_v6p: { pointer_t stack = *pr->globals.stack - 4; pr_type_t *stk = pr->pr_globals + stack; @@ -1185,13 +1185,13 @@ pr_exec_quakec (progs_t *pr, int exitdepth) } break; - case OP_POP_F: - case OP_POP_FLD: - case OP_POP_ENT: - case OP_POP_S: - case OP_POP_FN: - case OP_POP_I: - case OP_POP_P: + case OP_POP_F_v6p: + case OP_POP_FLD_v6p: + case OP_POP_ENT_v6p: + case OP_POP_S_v6p: + case OP_POP_FN_v6p: + case OP_POP_I_v6p: + case OP_POP_P_v6p: { pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; @@ -1202,7 +1202,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *pr->globals.stack = stack + 1; } break; - case OP_POP_V: + case OP_POP_V_v6p: { pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; @@ -1213,7 +1213,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *pr->globals.stack = stack + 3; } break; - case OP_POP_Q: + case OP_POP_Q_v6p: { pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; @@ -1225,13 +1225,13 @@ pr_exec_quakec (progs_t *pr, int exitdepth) } break; - case OP_POPB_F: - case OP_POPB_S: - case OP_POPB_ENT: - case OP_POPB_FLD: - case OP_POPB_FN: - case OP_POPB_I: - case OP_POPB_P: + case OP_POPB_F_v6p: + case OP_POPB_S_v6p: + case OP_POPB_ENT_v6p: + case OP_POPB_FLD_v6p: + case OP_POPB_FN_v6p: + case OP_POPB_I_v6p: + case OP_POPB_P_v6p: { pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; @@ -1248,7 +1248,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *pr->globals.stack = stack + 1; } break; - case OP_POPB_V: + case OP_POPB_V_v6p: { pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; @@ -1265,7 +1265,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *pr->globals.stack = stack + 3; } break; - case OP_POPB_Q: + case OP_POPB_Q_v6p: { pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; @@ -1283,13 +1283,13 @@ pr_exec_quakec (progs_t *pr, int exitdepth) } break; - case OP_POPBI_F: - case OP_POPBI_S: - case OP_POPBI_ENT: - case OP_POPBI_FLD: - case OP_POPBI_FN: - case OP_POPBI_I: - case OP_POPBI_P: + case OP_POPBI_F_v6p: + case OP_POPBI_S_v6p: + case OP_POPBI_ENT_v6p: + case OP_POPBI_FLD_v6p: + case OP_POPBI_FN_v6p: + case OP_POPBI_I_v6p: + case OP_POPBI_P_v6p: { pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; @@ -1306,7 +1306,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *pr->globals.stack = stack + 1; } break; - case OP_POPBI_V: + case OP_POPBI_V_v6p: { pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; @@ -1323,7 +1323,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) *pr->globals.stack = stack + 3; } break; - case OP_POPBI_Q: + case OP_POPBI_Q_v6p: { pointer_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; @@ -1342,47 +1342,47 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; // ================== - case OP_IFNOT: + case OP_IFNOT_v6p: if (!OPA(int)) { pr->pr_xstatement += (short)st->b - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; } break; - case OP_IF: + case OP_IF_v6p: if (OPA(int)) { pr->pr_xstatement += (short)st->b - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; } break; - case OP_IFBE: + case OP_IFBE_v6p: if (OPA(int) <= 0) { pr->pr_xstatement += (short)st->b - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; } break; - case OP_IFB: + case OP_IFB_v6p: if (OPA(int) < 0) { pr->pr_xstatement += (short)st->b - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; } break; - case OP_IFAE: + case OP_IFAE_v6p: if (OPA(int) >= 0) { pr->pr_xstatement += (short)st->b - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; } break; - case OP_IFA: + case OP_IFA_v6p: if (OPA(int) > 0) { pr->pr_xstatement += (short)st->b - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; } break; - case OP_GOTO: + case OP_GOTO_v6p: pr->pr_xstatement += (short)st->a - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; break; - case OP_JUMP: + case OP_JUMP_v6p: if (pr_boundscheck->int_val && (OPA(uint) >= pr->progs->numstatements)) { PR_RunError (pr, "Invalid jump destination"); @@ -1390,7 +1390,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr->pr_xstatement = OPA(uint) - 1; // offset the st++ st = pr->pr_statements + pr->pr_xstatement; break; - case OP_JUMPB: + case OP_JUMPB_v6p: pointer = st->a + OPB(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_integer); @@ -1405,40 +1405,40 @@ pr_exec_quakec (progs_t *pr, int exitdepth) st = pr->pr_statements + pr->pr_xstatement; break; - case OP_RCALL2: - case OP_RCALL3: - case OP_RCALL4: - case OP_RCALL5: - case OP_RCALL6: - case OP_RCALL7: - case OP_RCALL8: + case OP_RCALL2_v6p: + case OP_RCALL3_v6p: + case OP_RCALL4_v6p: + case OP_RCALL5_v6p: + case OP_RCALL6_v6p: + case OP_RCALL7_v6p: + case OP_RCALL8_v6p: pr->pr_params[1] = op_c; goto op_rcall; - case OP_RCALL1: + case OP_RCALL1_v6p: pr->pr_params[1] = pr->pr_real_params[1]; op_rcall: pr->pr_params[0] = op_b; - pr->pr_argc = st->op - OP_RCALL1 + 1; + pr->pr_argc = st->op - OP_RCALL1_v6p + 1; goto op_call; - case OP_CALL0: - case OP_CALL1: - case OP_CALL2: - case OP_CALL3: - case OP_CALL4: - case OP_CALL5: - case OP_CALL6: - case OP_CALL7: - case OP_CALL8: + case OP_CALL0_v6p: + case OP_CALL1_v6p: + case OP_CALL2_v6p: + case OP_CALL3_v6p: + case OP_CALL4_v6p: + case OP_CALL5_v6p: + case OP_CALL6_v6p: + case OP_CALL7_v6p: + case OP_CALL8_v6p: PR_RESET_PARAMS (pr); - pr->pr_argc = st->op - OP_CALL0; + pr->pr_argc = st->op - OP_CALL0_v6p; op_call: pr->pr_xfunction->profile += profile - startprofile; startprofile = profile; PR_CallFunction (pr, OPA(uint)); st = pr->pr_statements + pr->pr_xstatement; break; - case OP_DONE: - case OP_RETURN: + case OP_DONE_v6p: + case OP_RETURN_v6p: if (!st->a) memset (&R_INT (pr), 0, pr->pr_param_size * sizeof (*op_a)); @@ -1446,7 +1446,7 @@ op_call: memcpy (&R_INT (pr), op_a, pr->pr_param_size * sizeof (*op_a)); // fallthrough - case OP_RETURN_V: + case OP_RETURN_V_v6p: pr->pr_xfunction->profile += profile - startprofile; startprofile = profile; PR_LeaveFunction (pr, pr->pr_depth == exitdepth); @@ -1458,7 +1458,7 @@ op_call: goto exit_program; } break; - case OP_STATE: + case OP_STATE_v6p: { int self = *pr->globals.self; int nextthink = pr->fields.nextthink + self; @@ -1470,7 +1470,7 @@ op_call: pr->pr_edict_area[think].func_var = OPB(uint); } break; - case OP_STATE_F: + case OP_STATE_F_v6p: { int self = *pr->globals.self; int nextthink = pr->fields.nextthink + self; @@ -1482,19 +1482,19 @@ op_call: pr->pr_edict_area[think].func_var = OPB(uint); } break; - case OP_ADD_I: + case OP_ADD_I_v6p: OPC(int) = OPA(int) + OPB(int); break; - case OP_SUB_I: + case OP_SUB_I_v6p: OPC(int) = OPA(int) - OPB(int); break; - case OP_MUL_I: + case OP_MUL_I_v6p: OPC(int) = OPA(int) * OPB(int); break; - case OP_DIV_I: + case OP_DIV_I_v6p: OPC(int) = OPA(int) / OPB(int); break; - case OP_MOD_I: + case OP_MOD_I_v6p: { // implement true modulo for integers: // 5 mod 3 = 2 @@ -1512,10 +1512,10 @@ op_call: OPC(int) = c + (mask & b); } break; - case OP_REM_I: + case OP_REM_I_v6p: OPC(int) = OPA(int) % OPB(int); break; - case OP_MOD_D: + case OP_MOD_D_v6p: { double a = OPA(double); double b = OPB(double); @@ -1523,98 +1523,98 @@ op_call: OPC(double) = a - b * floor (a / b); } break; - case OP_REM_D: + case OP_REM_D_v6p: { double a = OPA(double); double b = OPB(double); OPC(double) = a - b * trunc (a / b); } break; - case OP_MOD_F: + case OP_MOD_F_v6p: { float a = OPA(float); float b = OPB(float); OPC(float) = a - b * floorf (a / b); } break; - case OP_REM_F: + case OP_REM_F_v6p: { float a = OPA(float); float b = OPB(float); OPC(float) = a - b * truncf (a / b); } break; - case OP_CONV_IF: + case OP_CONV_IF_v6p: OPC(float) = OPA(int); break; - case OP_CONV_FI: + case OP_CONV_FI_v6p: OPC(int) = OPA(float); break; - case OP_BITAND_I: + case OP_BITAND_I_v6p: OPC(int) = OPA(int) & OPB(int); break; - case OP_BITOR_I: + case OP_BITOR_I_v6p: OPC(int) = OPA(int) | OPB(int); break; - case OP_BITXOR_I: + case OP_BITXOR_I_v6p: OPC(int) = OPA(int) ^ OPB(int); break; - case OP_BITNOT_I: + case OP_BITNOT_I_v6p: OPC(int) = ~OPA(int); break; - case OP_GE_I: - case OP_GE_P: + case OP_GE_I_v6p: + case OP_GE_P_v6p: OPC(int) = OPA(int) >= OPB(int); break; - case OP_GE_U: + case OP_GE_U_v6p: OPC(int) = OPA(uint) >= OPB(uint); break; - case OP_LE_I: - case OP_LE_P: + case OP_LE_I_v6p: + case OP_LE_P_v6p: OPC(int) = OPA(int) <= OPB(int); break; - case OP_LE_U: + case OP_LE_U_v6p: OPC(int) = OPA(uint) <= OPB(uint); break; - case OP_GT_I: - case OP_GT_P: + case OP_GT_I_v6p: + case OP_GT_P_v6p: OPC(int) = OPA(int) > OPB(int); break; - case OP_GT_U: + case OP_GT_U_v6p: OPC(int) = OPA(uint) > OPB(uint); break; - case OP_LT_I: - case OP_LT_P: + case OP_LT_I_v6p: + case OP_LT_P_v6p: OPC(int) = OPA(int) < OPB(int); break; - case OP_LT_U: + case OP_LT_U_v6p: OPC(int) = OPA(uint) < OPB(uint); break; - case OP_AND_I: + case OP_AND_I_v6p: OPC(int) = OPA(int) && OPB(int); break; - case OP_OR_I: + case OP_OR_I_v6p: OPC(int) = OPA(int) || OPB(int); break; - case OP_NOT_I: - case OP_NOT_P: + case OP_NOT_I_v6p: + case OP_NOT_P_v6p: OPC(int) = !OPA(int); break; - case OP_EQ_I: - case OP_EQ_P: + case OP_EQ_I_v6p: + case OP_EQ_P_v6p: OPC(int) = OPA(int) == OPB(int); break; - case OP_NE_I: - case OP_NE_P: + case OP_NE_I_v6p: + case OP_NE_P_v6p: OPC(int) = OPA(int) != OPB(int); break; - case OP_MOVEI: + case OP_MOVEI_v6p: memmove (op_c, op_a, st->b * 4); break; - case OP_MOVEP: + case OP_MOVEP_v6p: if (pr_boundscheck->int_val) { PR_BoundsCheckSize (pr, OPC(int), OPB(uint)); PR_BoundsCheckSize (pr, OPA(int), OPB(uint)); @@ -1623,7 +1623,7 @@ op_call: pr->pr_globals + OPA(int), OPB(uint) * 4); break; - case OP_MOVEPI: + case OP_MOVEPI_v6p: if (pr_boundscheck->int_val) { PR_BoundsCheckSize (pr, OPC(int), st->b); PR_BoundsCheckSize (pr, OPA(int), st->b); @@ -1632,61 +1632,61 @@ op_call: pr->pr_globals + OPA(int), st->b * 4); break; - case OP_MEMSETI: + case OP_MEMSETI_v6p: pr_memset (op_c, OPA(int), st->b); break; - case OP_MEMSETP: + case OP_MEMSETP_v6p: if (pr_boundscheck->int_val) { PR_BoundsCheckSize (pr, OPC(pointer), OPB(int)); } pr_memset (pr->pr_globals + OPC(pointer), OPA(int), OPB(int)); break; - case OP_MEMSETPI: + case OP_MEMSETPI_v6p: if (pr_boundscheck->int_val) { PR_BoundsCheckSize (pr, OPC(pointer), st->b); } pr_memset (pr->pr_globals + OPC(pointer), OPA(int), st->b); break; - case OP_GE_D: + case OP_GE_D_v6p: OPC(float) = OPA(double) >= OPB(double); break; - case OP_LE_D: + case OP_LE_D_v6p: OPC(float) = OPA(double) <= OPB(double); break; - case OP_GT_D: + case OP_GT_D_v6p: OPC(float) = OPA(double) > OPB(double); break; - case OP_LT_D: + case OP_LT_D_v6p: OPC(float) = OPA(double) < OPB(double); break; - case OP_NOT_D: + case OP_NOT_D_v6p: OPC(int) = (op_a[0].integer_var || (op_a[1].integer_var & ~0x80000000u)); break; - case OP_EQ_D: + case OP_EQ_D_v6p: OPC(int) = OPA(double) == OPB(double); break; - case OP_NE_D: + case OP_NE_D_v6p: OPC(int) = OPA(double) != OPB(double); break; - case OP_CONV_ID: + case OP_CONV_ID_v6p: OPC(double) = OPA(int); break; - case OP_CONV_DI: + case OP_CONV_DI_v6p: OPC(int) = OPA(double); break; - case OP_CONV_FD: + case OP_CONV_FD_v6p: OPC(double) = OPA(float); break; - case OP_CONV_DF: + case OP_CONV_DF_v6p: OPC(float) = OPA(double); break; // LordHavoc: to be enabled when Progs version 7 (or whatever it will be numbered) is finalized /* - case OP_BOUNDCHECK: + case OP_BOUNDCHECK_v6p: if (OPA(int) < 0 || OPA(int) >= st->b) { PR_RunError (pr, "Progs boundcheck failed at line number " "%d, value is < 0 or >= %d", st->b, st->c); diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index 955cc0796..17d640575 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -95,1431 +95,1431 @@ VISIBLE const char * const pr_type_name[ev_type_count] = { // c operand c // x place holder for P (padding) // 0-7 parameter index (for P) -VISIBLE const opcode_t pr_opcodes[] = { - // OP_DONE is actually the same as OP_RETURN, the types are bogus - [OP_DONE] = {"", "done", +VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { + // OP_DONE_v6p is actually the same as OP_RETURN_v6p, the types are bogus + [OP_DONE_v6p] = {"", "done", ev_entity, ev_field, ev_void, PROG_ID_VERSION, "%Va", }, - [OP_MUL_D] = {"*", "mul.d", + [OP_MUL_D_v6p] = {"*", "mul.d", ev_double, ev_double, ev_double, PROG_VERSION, }, - [OP_MUL_F] = {"*", "mul.f", + [OP_MUL_F_v6p] = {"*", "mul.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_MUL_V] = {"*", "mul.v", + [OP_MUL_V_v6p] = {"*", "mul.v", ev_vector, ev_vector, ev_float, PROG_ID_VERSION, }, - [OP_MUL_FV] = {"*", "mul.fv", + [OP_MUL_FV_v6p] = {"*", "mul.fv", ev_float, ev_vector, ev_vector, PROG_ID_VERSION, }, - [OP_MUL_VF] = {"*", "mul.vf", + [OP_MUL_VF_v6p] = {"*", "mul.vf", ev_vector, ev_float, ev_vector, PROG_ID_VERSION, }, - [OP_MUL_DV] = {"*", "mul.dv", + [OP_MUL_DV_v6p] = {"*", "mul.dv", ev_double, ev_vector, ev_vector, PROG_ID_VERSION, }, - [OP_MUL_VD] = {"*", "mul.vd", + [OP_MUL_VD_v6p] = {"*", "mul.vd", ev_vector, ev_double, ev_vector, PROG_ID_VERSION, }, - [OP_MUL_Q] = {"*", "mul.q", + [OP_MUL_Q_v6p] = {"*", "mul.q", ev_quat, ev_quat, ev_quat, PROG_VERSION, }, - [OP_MUL_FQ] = {"*", "mul.fq", + [OP_MUL_FQ_v6p] = {"*", "mul.fq", ev_float, ev_quat, ev_quat, PROG_VERSION, }, - [OP_MUL_QF] = {"*", "mul.qf", + [OP_MUL_QF_v6p] = {"*", "mul.qf", ev_quat, ev_float, ev_quat, PROG_VERSION, }, - [OP_MUL_DQ] = {"*", "mul.dq", + [OP_MUL_DQ_v6p] = {"*", "mul.dq", ev_double, ev_quat, ev_quat, PROG_VERSION, }, - [OP_MUL_QD] = {"*", "mul.qd", + [OP_MUL_QD_v6p] = {"*", "mul.qd", ev_quat, ev_double, ev_quat, PROG_VERSION, }, - [OP_MUL_QV] = {"*", "mul.qv", + [OP_MUL_QV_v6p] = {"*", "mul.qv", ev_quat, ev_vector, ev_vector, PROG_VERSION, }, - [OP_CONJ_Q] = {"~", "conj.q", + [OP_CONJ_Q_v6p] = {"~", "conj.q", ev_quat, ev_invalid, ev_quat, PROG_VERSION, "%Ga, %gc", }, - [OP_DIV_F] = {"/", "div.f", + [OP_DIV_F_v6p] = {"/", "div.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_DIV_D] = {"/", "div.d", + [OP_DIV_D_v6p] = {"/", "div.d", ev_double, ev_double, ev_double, PROG_VERSION, }, - [OP_REM_D] = {"%", "rem.d", + [OP_REM_D_v6p] = {"%", "rem.d", ev_double, ev_double, ev_double, PROG_VERSION, }, - [OP_MOD_D] = {"%%", "mod.d", + [OP_MOD_D_v6p] = {"%%", "mod.d", ev_double, ev_double, ev_double, PROG_VERSION, }, - [OP_ADD_D] = {"+", "add.d", + [OP_ADD_D_v6p] = {"+", "add.d", ev_double, ev_double, ev_double, PROG_VERSION, }, - [OP_ADD_F] = {"+", "add.f", + [OP_ADD_F_v6p] = {"+", "add.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_ADD_V] = {"+", "add.v", + [OP_ADD_V_v6p] = {"+", "add.v", ev_vector, ev_vector, ev_vector, PROG_ID_VERSION, }, - [OP_ADD_Q] = {"+", "add.q", + [OP_ADD_Q_v6p] = {"+", "add.q", ev_quat, ev_quat, ev_quat, PROG_VERSION, }, - [OP_ADD_S] = {"+", "add.s", + [OP_ADD_S_v6p] = {"+", "add.s", ev_string, ev_string, ev_string, PROG_VERSION, }, - [OP_SUB_D] = {"-", "sub.d", + [OP_SUB_D_v6p] = {"-", "sub.d", ev_double, ev_double, ev_double, PROG_VERSION, }, - [OP_SUB_F] = {"-", "sub.f", + [OP_SUB_F_v6p] = {"-", "sub.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_SUB_V] = {"-", "sub.v", + [OP_SUB_V_v6p] = {"-", "sub.v", ev_vector, ev_vector, ev_vector, PROG_ID_VERSION, }, - [OP_SUB_Q] = {"-", "sub.q", + [OP_SUB_Q_v6p] = {"-", "sub.q", ev_quat, ev_quat, ev_quat, PROG_VERSION, }, - [OP_EQ_D] = {"==", "eq.d", + [OP_EQ_D_v6p] = {"==", "eq.d", ev_double, ev_double, ev_integer, PROG_VERSION, }, - [OP_EQ_F] = {"==", "eq.f", + [OP_EQ_F_v6p] = {"==", "eq.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_EQ_V] = {"==", "eq.v", + [OP_EQ_V_v6p] = {"==", "eq.v", ev_vector, ev_vector, ev_integer, PROG_ID_VERSION, }, - [OP_EQ_Q] = {"==", "eq.q", + [OP_EQ_Q_v6p] = {"==", "eq.q", ev_quat, ev_quat, ev_integer, PROG_VERSION, }, - [OP_EQ_S] = {"==", "eq.s", + [OP_EQ_S_v6p] = {"==", "eq.s", ev_string, ev_string, ev_integer, PROG_ID_VERSION, }, - [OP_EQ_E] = {"==", "eq.e", + [OP_EQ_E_v6p] = {"==", "eq.e", ev_entity, ev_entity, ev_integer, PROG_ID_VERSION, }, - [OP_EQ_FN] = {"==", "eq.fn", + [OP_EQ_FN_v6p] = {"==", "eq.fn", ev_func, ev_func, ev_integer, PROG_ID_VERSION, }, - [OP_NE_D] = {"!=", "ne.d", + [OP_NE_D_v6p] = {"!=", "ne.d", ev_double, ev_double, ev_integer, PROG_VERSION, }, - [OP_NE_F] = {"!=", "ne.f", + [OP_NE_F_v6p] = {"!=", "ne.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_NE_V] = {"!=", "ne.v", + [OP_NE_V_v6p] = {"!=", "ne.v", ev_vector, ev_vector, ev_integer, PROG_ID_VERSION, }, - [OP_NE_Q] = {"!=", "ne.q", + [OP_NE_Q_v6p] = {"!=", "ne.q", ev_quat, ev_quat, ev_integer, PROG_VERSION, }, - [OP_NE_S] = {"!=", "ne.s", + [OP_NE_S_v6p] = {"!=", "ne.s", ev_string, ev_string, ev_integer, PROG_ID_VERSION, }, - [OP_NE_E] = {"!=", "ne.e", + [OP_NE_E_v6p] = {"!=", "ne.e", ev_entity, ev_entity, ev_integer, PROG_ID_VERSION, }, - [OP_NE_FN] = {"!=", "ne.fn", + [OP_NE_FN_v6p] = {"!=", "ne.fn", ev_func, ev_func, ev_integer, PROG_ID_VERSION, }, - [OP_LE_D] = {"<=", "le.d", + [OP_LE_D_v6p] = {"<=", "le.d", ev_double, ev_double, ev_integer, PROG_VERSION, }, - [OP_LE_F] = {"<=", "le.f", + [OP_LE_F_v6p] = {"<=", "le.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_GE_D] = {">=", "ge.d", + [OP_GE_D_v6p] = {">=", "ge.d", ev_double, ev_double, ev_integer, PROG_VERSION, }, - [OP_GE_F] = {">=", "ge.f", + [OP_GE_F_v6p] = {">=", "ge.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_LE_S] = {"<=", "le.s", + [OP_LE_S_v6p] = {"<=", "le.s", ev_string, ev_string, ev_integer, PROG_VERSION, }, - [OP_GE_S] = {">=", "ge.s", + [OP_GE_S_v6p] = {">=", "ge.s", ev_string, ev_string, ev_integer, PROG_VERSION, }, - [OP_LT_D] = {"<", "lt.d", + [OP_LT_D_v6p] = {"<", "lt.d", ev_double, ev_double, ev_integer, PROG_VERSION, }, - [OP_LT_F] = {"<", "lt.f", + [OP_LT_F_v6p] = {"<", "lt.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_GT_D] = {">", "gt.d", + [OP_GT_D_v6p] = {">", "gt.d", ev_double, ev_double, ev_integer, PROG_VERSION, }, - [OP_GT_F] = {">", "gt.f", + [OP_GT_F_v6p] = {">", "gt.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_LT_S] = {"<", "lt.s", + [OP_LT_S_v6p] = {"<", "lt.s", ev_string, ev_string, ev_integer, PROG_VERSION, }, - [OP_GT_S] = {">", "gt.s", + [OP_GT_S_v6p] = {">", "gt.s", ev_string, ev_string, ev_integer, PROG_VERSION, }, - [OP_LOAD_F] = {".", "load.f", + [OP_LOAD_F_v6p] = {".", "load.f", ev_entity, ev_field, ev_float, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc",//FIXME %E more flexible? }, - [OP_LOAD_D] = {".", "load.d", + [OP_LOAD_D_v6p] = {".", "load.d", ev_entity, ev_field, ev_double, PROG_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_V] = {".", "load.v", + [OP_LOAD_V_v6p] = {".", "load.v", ev_entity, ev_field, ev_vector, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_Q] = {".", "load.q", + [OP_LOAD_Q_v6p] = {".", "load.q", ev_entity, ev_field, ev_quat, PROG_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_S] = {".", "load.s", + [OP_LOAD_S_v6p] = {".", "load.s", ev_entity, ev_field, ev_string, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_ENT] = {".", "load.ent", + [OP_LOAD_ENT_v6p] = {".", "load.ent", ev_entity, ev_field, ev_entity, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_FLD] = {".", "load.fld", + [OP_LOAD_FLD_v6p] = {".", "load.fld", ev_entity, ev_field, ev_field, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_FN] = {".", "load.fn", + [OP_LOAD_FN_v6p] = {".", "load.fn", ev_entity, ev_field, ev_func, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_I] = {".", "load.i", + [OP_LOAD_I_v6p] = {".", "load.i", ev_entity, ev_field, ev_integer, PROG_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_P] = {".", "load.p", + [OP_LOAD_P_v6p] = {".", "load.p", ev_entity, ev_field, ev_pointer, PROG_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOADB_D] = {".", "loadb.d", + [OP_LOADB_D_v6p] = {".", "loadb.d", ev_pointer, ev_integer, ev_double, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_F] = {".", "loadb.f", + [OP_LOADB_F_v6p] = {".", "loadb.f", ev_pointer, ev_integer, ev_float, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_V] = {".", "loadb.v", + [OP_LOADB_V_v6p] = {".", "loadb.v", ev_pointer, ev_integer, ev_vector, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_Q] = {".", "loadb.q", + [OP_LOADB_Q_v6p] = {".", "loadb.q", ev_pointer, ev_integer, ev_quat, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_S] = {".", "loadb.s", + [OP_LOADB_S_v6p] = {".", "loadb.s", ev_pointer, ev_integer, ev_string, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_ENT] = {".", "loadb.ent", + [OP_LOADB_ENT_v6p] = {".", "loadb.ent", ev_pointer, ev_integer, ev_entity, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_FLD] = {".", "loadb.fld", + [OP_LOADB_FLD_v6p] = {".", "loadb.fld", ev_pointer, ev_integer, ev_field, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_FN] = {".", "loadb.fn", + [OP_LOADB_FN_v6p] = {".", "loadb.fn", ev_pointer, ev_integer, ev_func, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_I] = {".", "loadb.i", + [OP_LOADB_I_v6p] = {".", "loadb.i", ev_pointer, ev_integer, ev_integer, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_P] = {".", "loadb.p", + [OP_LOADB_P_v6p] = {".", "loadb.p", ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADBI_D] = {".", "loadbi.d", + [OP_LOADBI_D_v6p] = {".", "loadbi.d", ev_pointer, ev_short, ev_double, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_F] = {".", "loadbi.f", + [OP_LOADBI_F_v6p] = {".", "loadbi.f", ev_pointer, ev_short, ev_float, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_V] = {".", "loadbi.v", + [OP_LOADBI_V_v6p] = {".", "loadbi.v", ev_pointer, ev_short, ev_vector, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_Q] = {".", "loadbi.q", + [OP_LOADBI_Q_v6p] = {".", "loadbi.q", ev_pointer, ev_short, ev_quat, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_S] = {".", "loadbi.s", + [OP_LOADBI_S_v6p] = {".", "loadbi.s", ev_pointer, ev_short, ev_string, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_ENT] = {".", "loadbi.ent", + [OP_LOADBI_ENT_v6p] = {".", "loadbi.ent", ev_pointer, ev_short, ev_entity, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_FLD] = {".", "loadbi.fld", + [OP_LOADBI_FLD_v6p] = {".", "loadbi.fld", ev_pointer, ev_short, ev_field, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_FN] = {".", "loadbi.fn", + [OP_LOADBI_FN_v6p] = {".", "loadbi.fn", ev_pointer, ev_short, ev_func, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_I] = {".", "loadbi.i", + [OP_LOADBI_I_v6p] = {".", "loadbi.i", ev_pointer, ev_short, ev_integer, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_P] = {".", "loadbi.p", + [OP_LOADBI_P_v6p] = {".", "loadbi.p", ev_pointer, ev_short, ev_pointer, PROG_VERSION, "*(%Ga + %sb), %gc", }, - [OP_ADDRESS] = {"&", "address", + [OP_ADDRESS_v6p] = {"&", "address", ev_entity, ev_field, ev_pointer, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_ADDRESS_VOID] = {"&", "address", + [OP_ADDRESS_VOID_v6p] = {"&", "address", ev_void, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_D] = {"&", "address.d", + [OP_ADDRESS_D_v6p] = {"&", "address.d", ev_double, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_F] = {"&", "address.f", + [OP_ADDRESS_F_v6p] = {"&", "address.f", ev_float, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_V] = {"&", "address.v", + [OP_ADDRESS_V_v6p] = {"&", "address.v", ev_vector, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_Q] = {"&", "address.q", + [OP_ADDRESS_Q_v6p] = {"&", "address.q", ev_quat, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_S] = {"&", "address.s", + [OP_ADDRESS_S_v6p] = {"&", "address.s", ev_string, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_ENT] = {"&", "address.ent", + [OP_ADDRESS_ENT_v6p] = {"&", "address.ent", ev_entity, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_FLD] = {"&", "address.fld", + [OP_ADDRESS_FLD_v6p] = {"&", "address.fld", ev_field, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_FN] = {"&", "address.fn", + [OP_ADDRESS_FN_v6p] = {"&", "address.fn", ev_func, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_I] = {"&", "address.i", + [OP_ADDRESS_I_v6p] = {"&", "address.i", ev_integer, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_P] = {"&", "address.p", + [OP_ADDRESS_P_v6p] = {"&", "address.p", ev_pointer, ev_invalid, ev_pointer, PROG_VERSION, "%Ga, %gc", }, - [OP_LEA] = {"&", "lea", + [OP_LEA_v6p] = {"&", "lea", ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "(%Ga + %Gb), %gc", }, - [OP_LEAI] = {"&", "leai", + [OP_LEAI_v6p] = {"&", "leai", ev_pointer, ev_short, ev_pointer, PROG_VERSION, "(%Ga + %sb), %gc", }, - [OP_CONV_IF] = {"", "conv.if", + [OP_CONV_IF_v6p] = {"", "conv.if", ev_integer, ev_invalid, ev_float, PROG_VERSION, "%Ga, %gc", }, - [OP_CONV_FI] = {"", "conv.fi", + [OP_CONV_FI_v6p] = {"", "conv.fi", ev_float, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_CONV_ID] = {"", "conv.id", + [OP_CONV_ID_v6p] = {"", "conv.id", ev_integer, ev_invalid, ev_double, PROG_VERSION, "%Ga, %gc", }, - [OP_CONV_DI] = {"", "conv.di", + [OP_CONV_DI_v6p] = {"", "conv.di", ev_double, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_CONV_FD] = {"", "conv.fd", + [OP_CONV_FD_v6p] = {"", "conv.fd", ev_float, ev_invalid, ev_double, PROG_VERSION, "%Ga, %gc", }, - [OP_CONV_DF] = {"", "conv.df", + [OP_CONV_DF_v6p] = {"", "conv.df", ev_double, ev_invalid, ev_float, PROG_VERSION, "%Ga, %gc", }, - [OP_STORE_D] = {"=", "store.d", + [OP_STORE_D_v6p] = {"=", "store.d", ev_double, ev_double, ev_invalid, PROG_VERSION, "%Ga, %gb", }, - [OP_STORE_F] = {"=", "store.f", + [OP_STORE_F_v6p] = {"=", "store.f", ev_float, ev_float, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_V] = {"=", "store.v", + [OP_STORE_V_v6p] = {"=", "store.v", ev_vector, ev_vector, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_Q] = {"=", "store.q", + [OP_STORE_Q_v6p] = {"=", "store.q", ev_quat, ev_quat, ev_invalid, PROG_VERSION, "%Ga, %gb", }, - [OP_STORE_S] = {"=", "store.s", + [OP_STORE_S_v6p] = {"=", "store.s", ev_string, ev_string, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_ENT] = {"=", "store.ent", + [OP_STORE_ENT_v6p] = {"=", "store.ent", ev_entity, ev_entity, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_FLD] = {"=", "store.fld", + [OP_STORE_FLD_v6p] = {"=", "store.fld", ev_field, ev_field, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_FN] = {"=", "store.fn", + [OP_STORE_FN_v6p] = {"=", "store.fn", ev_func, ev_func, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_I] = {"=", "store.i", + [OP_STORE_I_v6p] = {"=", "store.i", ev_integer, ev_integer, ev_invalid, PROG_VERSION, "%Ga, %gb", }, - [OP_STORE_P] = {"=", "store.p", + [OP_STORE_P_v6p] = {"=", "store.p", ev_pointer, ev_pointer, ev_invalid, PROG_VERSION, "%Ga, %gb", }, - [OP_STOREP_D] = {".=", "storep.d", + [OP_STOREP_D_v6p] = {".=", "storep.d", ev_double, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_F] = {".=", "storep.f", + [OP_STOREP_F_v6p] = {".=", "storep.f", ev_float, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_V] = {".=", "storep.v", + [OP_STOREP_V_v6p] = {".=", "storep.v", ev_vector, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_Q] = {".=", "storep.q", + [OP_STOREP_Q_v6p] = {".=", "storep.q", ev_quat, ev_pointer, ev_invalid, PROG_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_S] = {".=", "storep.s", + [OP_STOREP_S_v6p] = {".=", "storep.s", ev_string, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_ENT] = {".=", "storep.ent", + [OP_STOREP_ENT_v6p] = {".=", "storep.ent", ev_entity, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_FLD] = {".=", "storep.fld", + [OP_STOREP_FLD_v6p] = {".=", "storep.fld", ev_field, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_FN] = {".=", "storep.fn", + [OP_STOREP_FN_v6p] = {".=", "storep.fn", ev_func, ev_pointer, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_I] = {".=", "storep.i", + [OP_STOREP_I_v6p] = {".=", "storep.i", ev_integer, ev_pointer, ev_invalid, PROG_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_P] = {".=", "storep.p", + [OP_STOREP_P_v6p] = {".=", "storep.p", ev_pointer, ev_pointer, ev_invalid, PROG_VERSION, "%Ga, *%Gb", }, - [OP_STOREB_D] = {".=", "storeb.d", + [OP_STOREB_D_v6p] = {".=", "storeb.d", ev_double, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_F] = {".=", "storeb.f", + [OP_STOREB_F_v6p] = {".=", "storeb.f", ev_float, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_V] = {".=", "storeb.v", + [OP_STOREB_V_v6p] = {".=", "storeb.v", ev_vector, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_Q] = {".=", "storeb.q", + [OP_STOREB_Q_v6p] = {".=", "storeb.q", ev_quat, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_S] = {".=", "storeb.s", + [OP_STOREB_S_v6p] = {".=", "storeb.s", ev_string, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_ENT] = {".=", "storeb.ent", + [OP_STOREB_ENT_v6p] = {".=", "storeb.ent", ev_entity, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_FLD] = {".=", "storeb.fld", + [OP_STOREB_FLD_v6p] = {".=", "storeb.fld", ev_field, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_FN] = {".=", "storeb.fn", + [OP_STOREB_FN_v6p] = {".=", "storeb.fn", ev_func, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_I] = {".=", "storeb.i", + [OP_STOREB_I_v6p] = {".=", "storeb.i", ev_integer, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_P] = {".=", "storeb.p", + [OP_STOREB_P_v6p] = {".=", "storeb.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREBI_D] = {".=", "storebi.d", + [OP_STOREBI_D_v6p] = {".=", "storebi.d", ev_double, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_F] = {".=", "storebi.f", + [OP_STOREBI_F_v6p] = {".=", "storebi.f", ev_float, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_V] = {".=", "storebi.v", + [OP_STOREBI_V_v6p] = {".=", "storebi.v", ev_vector, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_Q] = {".=", "storebi.q", + [OP_STOREBI_Q_v6p] = {".=", "storebi.q", ev_quat, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_S] = {".=", "storebi.s", + [OP_STOREBI_S_v6p] = {".=", "storebi.s", ev_string, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_ENT] = {".=", "storebi.ent", + [OP_STOREBI_ENT_v6p] = {".=", "storebi.ent", ev_entity, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_FLD] = {".=", "storebi.fld", + [OP_STOREBI_FLD_v6p] = {".=", "storebi.fld", ev_field, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_FN] = {".=", "storebi.fn", + [OP_STOREBI_FN_v6p] = {".=", "storebi.fn", ev_func, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_I] = {".=", "storebi.i", + [OP_STOREBI_I_v6p] = {".=", "storebi.i", ev_integer, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_P] = {".=", "storebi.p", + [OP_STOREBI_P_v6p] = {".=", "storebi.p", ev_pointer, ev_pointer, ev_short, PROG_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_RETURN] = {"", "return", + [OP_RETURN_v6p] = {"", "return", ev_void, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Ra", }, - [OP_RETURN_V] = {"", "return", + [OP_RETURN_V_v6p] = {"", "return", ev_invalid, ev_invalid, ev_invalid, PROG_VERSION, "", }, - [OP_NOT_D] = {"!", "not.d", + [OP_NOT_D_v6p] = {"!", "not.d", ev_double, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_NOT_F] = {"!", "not.f", + [OP_NOT_F_v6p] = {"!", "not.f", ev_float, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_V] = {"!", "not.v", + [OP_NOT_V_v6p] = {"!", "not.v", ev_vector, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_Q] = {"!", "not.q", + [OP_NOT_Q_v6p] = {"!", "not.q", ev_quat, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_NOT_S] = {"!", "not.s", + [OP_NOT_S_v6p] = {"!", "not.s", ev_string, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_ENT] = {"!", "not.ent", + [OP_NOT_ENT_v6p] = {"!", "not.ent", ev_entity, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_FN] = {"!", "not.fn", + [OP_NOT_FN_v6p] = {"!", "not.fn", ev_func, ev_invalid, ev_integer, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_P] = {"!", "not.p", + [OP_NOT_P_v6p] = {"!", "not.p", ev_pointer, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_IF] = {"", "if", + [OP_IF_v6p] = {"", "if", ev_integer, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFNOT] = {"", "ifnot", + [OP_IFNOT_v6p] = {"", "ifnot", ev_integer, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFBE] = {"", "ifbe", + [OP_IFBE_v6p] = {"", "ifbe", ev_integer, ev_short, ev_invalid, PROG_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFB] = {"", "ifb", + [OP_IFB_v6p] = {"", "ifb", ev_integer, ev_short, ev_invalid, PROG_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFAE] = {"", "ifae", + [OP_IFAE_v6p] = {"", "ifae", ev_integer, ev_short, ev_invalid, PROG_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFA] = {"", "ifa", + [OP_IFA_v6p] = {"", "ifa", ev_integer, ev_short, ev_invalid, PROG_VERSION, "%Ga branch %sb (%Ob)", }, // calls returns REG_RETURN - [OP_CALL0] = {"", "call0", + [OP_CALL0_v6p] = {"", "call0", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa ()", }, - [OP_CALL1] = {"", "call1", + [OP_CALL1_v6p] = {"", "call1", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x)", }, - [OP_CALL2] = {"", "call2", + [OP_CALL2_v6p] = {"", "call2", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x)", }, - [OP_CALL3] = {"", "call3", + [OP_CALL3_v6p] = {"", "call3", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x)", }, - [OP_CALL4] = {"", "call4", + [OP_CALL4_v6p] = {"", "call4", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x)", }, - [OP_CALL5] = {"", "call5", + [OP_CALL5_v6p] = {"", "call5", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x)", }, - [OP_CALL6] = {"", "call6", + [OP_CALL6_v6p] = {"", "call6", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x)", }, - [OP_CALL7] = {"", "call7", + [OP_CALL7_v6p] = {"", "call7", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x, %P6x)", }, - [OP_CALL8] = {"", "call8", + [OP_CALL8_v6p] = {"", "call8", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x, %P6x, %P7x)", }, - [OP_RCALL0] = {"", 0, + [OP_RCALL0_v6p] = {"", 0, ev_invalid, ev_invalid, ev_invalid, ~0, // not a valid instruction 0, }, - [OP_RCALL1] = {"", "rcall1", + [OP_RCALL1_v6p] = {"", "rcall1", ev_func, ev_void, ev_invalid, PROG_VERSION, "%Fa (%P0b)", }, - [OP_RCALL2] = {"", "rcall2", + [OP_RCALL2_v6p] = {"", "rcall2", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c)", }, - [OP_RCALL3] = {"", "rcall3", + [OP_RCALL3_v6p] = {"", "rcall3", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x)", }, - [OP_RCALL4] = {"", "rcall4", + [OP_RCALL4_v6p] = {"", "rcall4", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x)", }, - [OP_RCALL5] = {"", "rcall5", + [OP_RCALL5_v6p] = {"", "rcall5", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x)", }, - [OP_RCALL6] = {"", "rcall6", + [OP_RCALL6_v6p] = {"", "rcall6", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x)", }, - [OP_RCALL7] = {"", "rcall7", + [OP_RCALL7_v6p] = {"", "rcall7", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x)", }, - [OP_RCALL8] = {"", "rcall8", + [OP_RCALL8_v6p] = {"", "rcall8", ev_func, ev_void, ev_void, PROG_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x, %P7x)", }, - [OP_STATE] = {"", "state", + [OP_STATE_v6p] = {"", "state", ev_float, ev_func, ev_invalid, PROG_ID_VERSION, "%Ga, %Gb", }, - [OP_STATE_F] = {"", "state.f", + [OP_STATE_F_v6p] = {"", "state.f", ev_float, ev_func, ev_float, PROG_VERSION, "%Ga, %Gb, %Gc", }, - [OP_GOTO] = {"", "goto", + [OP_GOTO_v6p] = {"", "goto", ev_short, ev_invalid, ev_invalid, PROG_ID_VERSION, "branch %sa (%Oa)", }, - [OP_JUMP] = {"", "jump", + [OP_JUMP_v6p] = {"", "jump", ev_integer, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_JUMPB] = {"", "jumpb", + [OP_JUMPB_v6p] = {"", "jumpb", ev_void, ev_integer, ev_invalid, PROG_VERSION, "%Ga[%Gb]", }, - [OP_AND] = {"&&", "and.f", + [OP_AND_v6p] = {"&&", "and.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_OR] = {"||", "or.f", + [OP_OR_v6p] = {"||", "or.f", ev_float, ev_float, ev_integer, PROG_ID_VERSION, }, - [OP_SHL_F] = {"<<", "shl.f", + [OP_SHL_F_v6p] = {"<<", "shl.f", ev_float, ev_float, ev_float, PROG_VERSION, }, - [OP_SHR_F] = {">>", "shr.f", + [OP_SHR_F_v6p] = {">>", "shr.f", ev_float, ev_float, ev_float, PROG_VERSION, }, - [OP_SHL_I] = {"<<", "shl.i", + [OP_SHL_I_v6p] = {"<<", "shl.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_SHR_I] = {">>", "shr.i", + [OP_SHR_I_v6p] = {">>", "shr.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_SHR_U] = {">>", "shr.u", + [OP_SHR_U_v6p] = {">>", "shr.u", ev_uinteger, ev_integer, ev_uinteger, PROG_VERSION, }, - [OP_BITAND] = {"&", "bitand", + [OP_BITAND_v6p] = {"&", "bitand", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_BITOR] = {"|", "bitor", + [OP_BITOR_v6p] = {"|", "bitor", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_ADD_I] = {"+", "add.i", + [OP_ADD_I_v6p] = {"+", "add.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_SUB_I] = {"-", "sub.i", + [OP_SUB_I_v6p] = {"-", "sub.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_MUL_I] = {"*", "mul.i", + [OP_MUL_I_v6p] = {"*", "mul.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_DIV_I] = {"/", "div.i", + [OP_DIV_I_v6p] = {"/", "div.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_REM_I] = {"%", "rem.i", + [OP_REM_I_v6p] = {"%", "rem.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_MOD_I] = {"%%", "mod.i", + [OP_MOD_I_v6p] = {"%%", "mod.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_BITAND_I] = {"&", "bitand.i", + [OP_BITAND_I_v6p] = {"&", "bitand.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_BITOR_I] = {"|", "bitor.i", + [OP_BITOR_I_v6p] = {"|", "bitor.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_REM_F] = {"%", "rem.f", + [OP_REM_F_v6p] = {"%", "rem.f", ev_float, ev_float, ev_float, PROG_VERSION, }, - [OP_MOD_F] = {"%%", "mod.f", + [OP_MOD_F_v6p] = {"%%", "mod.f", ev_float, ev_float, ev_float, PROG_VERSION, }, - [OP_GE_I] = {">=", "ge.i", + [OP_GE_I_v6p] = {">=", "ge.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_LE_I] = {"<=", "le.i", + [OP_LE_I_v6p] = {"<=", "le.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_GT_I] = {">", "gt.i", + [OP_GT_I_v6p] = {">", "gt.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_LT_I] = {"<", "lt.i", + [OP_LT_I_v6p] = {"<", "lt.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_AND_I] = {"&&", "and.i", + [OP_AND_I_v6p] = {"&&", "and.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_OR_I] = {"||", "or.i", + [OP_OR_I_v6p] = {"||", "or.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_NOT_I] = {"!", "not.i", + [OP_NOT_I_v6p] = {"!", "not.i", ev_integer, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_EQ_I] = {"==", "eq.i", + [OP_EQ_I_v6p] = {"==", "eq.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_NE_I] = {"!=", "ne.i", + [OP_NE_I_v6p] = {"!=", "ne.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_GE_U] = {">=", "ge.u", + [OP_GE_U_v6p] = {">=", "ge.u", ev_uinteger, ev_uinteger, ev_integer, PROG_VERSION, }, - [OP_LE_U] = {"<=", "le.u", + [OP_LE_U_v6p] = {"<=", "le.u", ev_uinteger, ev_uinteger, ev_integer, PROG_VERSION, }, - [OP_GT_U] = {">", "gt.u", + [OP_GT_U_v6p] = {">", "gt.u", ev_uinteger, ev_uinteger, ev_integer, PROG_VERSION, }, - [OP_LT_U] = {"<", "lt.u", + [OP_LT_U_v6p] = {"<", "lt.u", ev_uinteger, ev_uinteger, ev_integer, PROG_VERSION, }, - [OP_BITXOR_F] = {"^", "bitxor.f", + [OP_BITXOR_F_v6p] = {"^", "bitxor.f", ev_float, ev_float, ev_float, PROG_VERSION, }, - [OP_BITNOT_F] = {"~", "bitnot.f", + [OP_BITNOT_F_v6p] = {"~", "bitnot.f", ev_float, ev_invalid, ev_float, PROG_VERSION, "%Ga, %gc", }, - [OP_BITXOR_I] = {"^", "bitxor.i", + [OP_BITXOR_I_v6p] = {"^", "bitxor.i", ev_integer, ev_integer, ev_integer, PROG_VERSION, }, - [OP_BITNOT_I] = {"~", "bitnot.i", + [OP_BITNOT_I_v6p] = {"~", "bitnot.i", ev_integer, ev_invalid, ev_integer, PROG_VERSION, "%Ga, %gc", }, - [OP_GE_P] = {">=", "ge.p", + [OP_GE_P_v6p] = {">=", "ge.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - [OP_LE_P] = {"<=", "le.p", + [OP_LE_P_v6p] = {"<=", "le.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - [OP_GT_P] = {">", "gt.p", + [OP_GT_P_v6p] = {">", "gt.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - [OP_LT_P] = {"<", "lt.p", + [OP_LT_P_v6p] = {"<", "lt.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - [OP_EQ_P] = {"==", "eq.p", + [OP_EQ_P_v6p] = {"==", "eq.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - [OP_NE_P] = {"!=", "ne.p", + [OP_NE_P_v6p] = {"!=", "ne.p", ev_pointer, ev_pointer, ev_integer, PROG_VERSION, }, - [OP_MOVEI] = {"", "movei", + [OP_MOVEI_v6p] = {"", "movei", ev_void, ev_short, ev_void, PROG_VERSION, "%Ga, %sb, %gc", }, - [OP_MOVEP] = {"", "movep", + [OP_MOVEP_v6p] = {"", "movep", ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "%Ga, %Gb, %Gc", }, - [OP_MOVEPI] = {"", "movepi", + [OP_MOVEPI_v6p] = {"", "movepi", ev_pointer, ev_short, ev_pointer, PROG_VERSION, "%Ga, %sb, %Gc", }, - [OP_MEMSETI] = {"", "memseti", + [OP_MEMSETI_v6p] = {"", "memseti", ev_integer, ev_short, ev_void, PROG_VERSION, "%Ga, %sb, %gc", }, - [OP_MEMSETP] = {"", "memsetp", + [OP_MEMSETP_v6p] = {"", "memsetp", ev_integer, ev_integer, ev_pointer, PROG_VERSION, "%Ga, %Gb, %Gc", }, - [OP_MEMSETPI] = {"", "memsetpi", + [OP_MEMSETPI_v6p] = {"", "memsetpi", ev_integer, ev_short, ev_pointer, PROG_VERSION, "%Ga, %sb, %Gc", }, - [OP_PUSH_S] = {"", "push.s", + [OP_PUSH_S_v6p] = {"", "push.s", ev_string, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_F] = {"", "push.f", + [OP_PUSH_F_v6p] = {"", "push.f", ev_float, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_V] = {"", "push.v", + [OP_PUSH_V_v6p] = {"", "push.v", ev_vector, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_ENT] = {"", "push.ent", + [OP_PUSH_ENT_v6p] = {"", "push.ent", ev_entity, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_FLD] = {"", "push.fld", + [OP_PUSH_FLD_v6p] = {"", "push.fld", ev_field, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_FN] = {"", "push.fn", + [OP_PUSH_FN_v6p] = {"", "push.fn", ev_func, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_P] = {"", "push.p", + [OP_PUSH_P_v6p] = {"", "push.p", ev_pointer, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_Q] = {"", "push.q", + [OP_PUSH_Q_v6p] = {"", "push.q", ev_quat, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_I] = {"", "push.i", + [OP_PUSH_I_v6p] = {"", "push.i", ev_integer, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSH_D] = {"", "push.d", + [OP_PUSH_D_v6p] = {"", "push.d", ev_double, ev_invalid, ev_invalid, PROG_VERSION, "%Ga", }, - [OP_PUSHB_S] = {"", "pushb.s", + [OP_PUSHB_S_v6p] = {"", "pushb.s", ev_pointer, ev_integer, ev_string, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_F] = {"", "pushb.f", + [OP_PUSHB_F_v6p] = {"", "pushb.f", ev_pointer, ev_integer, ev_float, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_V] = {"", "pushb.v", + [OP_PUSHB_V_v6p] = {"", "pushb.v", ev_pointer, ev_integer, ev_vector, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_ENT] = {"", "pushb.ent", + [OP_PUSHB_ENT_v6p] = {"", "pushb.ent", ev_pointer, ev_integer, ev_entity, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_FLD] = {"", "pushb.fld", + [OP_PUSHB_FLD_v6p] = {"", "pushb.fld", ev_pointer, ev_integer, ev_field, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_FN] = {"", "pushb.fn", + [OP_PUSHB_FN_v6p] = {"", "pushb.fn", ev_pointer, ev_integer, ev_func, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_P] = {"", "pushb.p", + [OP_PUSHB_P_v6p] = {"", "pushb.p", ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_Q] = {"", "pushb.q", + [OP_PUSHB_Q_v6p] = {"", "pushb.q", ev_pointer, ev_integer, ev_quat, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_I] = {"", "pushb.i", + [OP_PUSHB_I_v6p] = {"", "pushb.i", ev_pointer, ev_integer, ev_integer, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_D] = {"", "pushb.d", + [OP_PUSHB_D_v6p] = {"", "pushb.d", ev_pointer, ev_integer, ev_double, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHBI_S] = {"", "pushbi.s", + [OP_PUSHBI_S_v6p] = {"", "pushbi.s", ev_pointer, ev_short, ev_string, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_F] = {"", "pushbi.f", + [OP_PUSHBI_F_v6p] = {"", "pushbi.f", ev_pointer, ev_short, ev_float, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_V] = {"", "pushbi.v", + [OP_PUSHBI_V_v6p] = {"", "pushbi.v", ev_pointer, ev_short, ev_vector, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_ENT] = {"", "pushbi.ent", + [OP_PUSHBI_ENT_v6p] = {"", "pushbi.ent", ev_pointer, ev_short, ev_entity, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_FLD] = {"", "pushbi.fld", + [OP_PUSHBI_FLD_v6p] = {"", "pushbi.fld", ev_pointer, ev_short, ev_field, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_FN] = {"", "pushbi.fn", + [OP_PUSHBI_FN_v6p] = {"", "pushbi.fn", ev_pointer, ev_short, ev_func, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_P] = {"", "pushbi.p", + [OP_PUSHBI_P_v6p] = {"", "pushbi.p", ev_pointer, ev_short, ev_pointer, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_Q] = {"", "pushbi.q", + [OP_PUSHBI_Q_v6p] = {"", "pushbi.q", ev_pointer, ev_short, ev_quat, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_I] = {"", "pushbi.i", + [OP_PUSHBI_I_v6p] = {"", "pushbi.i", ev_pointer, ev_short, ev_integer, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_D] = {"", "pushbi.d", + [OP_PUSHBI_D_v6p] = {"", "pushbi.d", ev_pointer, ev_short, ev_double, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POP_S] = {"", "pop.s", + [OP_POP_S_v6p] = {"", "pop.s", ev_string, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_F] = {"", "pop.f", + [OP_POP_F_v6p] = {"", "pop.f", ev_float, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_V] = {"", "pop.v", + [OP_POP_V_v6p] = {"", "pop.v", ev_vector, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_ENT] = {"", "pop.ent", + [OP_POP_ENT_v6p] = {"", "pop.ent", ev_entity, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_FLD] = {"", "pop.fld", + [OP_POP_FLD_v6p] = {"", "pop.fld", ev_field, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_FN] = {"", "pop.fn", + [OP_POP_FN_v6p] = {"", "pop.fn", ev_func, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_P] = {"", "pop.p", + [OP_POP_P_v6p] = {"", "pop.p", ev_pointer, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_Q] = {"", "pop.q", + [OP_POP_Q_v6p] = {"", "pop.q", ev_quat, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_I] = {"", "pop.i", + [OP_POP_I_v6p] = {"", "pop.i", ev_integer, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POP_D] = {"", "pop.d", + [OP_POP_D_v6p] = {"", "pop.d", ev_double, ev_invalid, ev_invalid, PROG_VERSION, "%ga", }, - [OP_POPB_S] = {"", "popb.s", + [OP_POPB_S_v6p] = {"", "popb.s", ev_pointer, ev_integer, ev_string, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_F] = {"", "popb.f", + [OP_POPB_F_v6p] = {"", "popb.f", ev_pointer, ev_integer, ev_float, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_V] = {"", "popb.v", + [OP_POPB_V_v6p] = {"", "popb.v", ev_pointer, ev_integer, ev_vector, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_ENT] = {"", "popb.ent", + [OP_POPB_ENT_v6p] = {"", "popb.ent", ev_pointer, ev_integer, ev_entity, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_FLD] = {"", "popb.fld", + [OP_POPB_FLD_v6p] = {"", "popb.fld", ev_pointer, ev_integer, ev_field, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_FN] = {"", "popb.fn", + [OP_POPB_FN_v6p] = {"", "popb.fn", ev_pointer, ev_integer, ev_func, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_P] = {"", "popb.p", + [OP_POPB_P_v6p] = {"", "popb.p", ev_pointer, ev_integer, ev_pointer, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_Q] = {"", "popb.q", + [OP_POPB_Q_v6p] = {"", "popb.q", ev_pointer, ev_integer, ev_quat, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_I] = {"", "popb.i", + [OP_POPB_I_v6p] = {"", "popb.i", ev_pointer, ev_integer, ev_integer, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_D] = {"", "popb.d", + [OP_POPB_D_v6p] = {"", "popb.d", ev_pointer, ev_integer, ev_double, PROG_VERSION, "*(%Ga + %Gb)", }, - [OP_POPBI_S] = {"", "popbi.s", + [OP_POPBI_S_v6p] = {"", "popbi.s", ev_pointer, ev_short, ev_string, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_F] = {"", "popbi.f", + [OP_POPBI_F_v6p] = {"", "popbi.f", ev_pointer, ev_short, ev_float, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_V] = {"", "popbi.v", + [OP_POPBI_V_v6p] = {"", "popbi.v", ev_pointer, ev_short, ev_vector, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_ENT] = {"", "popbi.ent", + [OP_POPBI_ENT_v6p] = {"", "popbi.ent", ev_pointer, ev_short, ev_entity, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_FLD] = {"", "popbi.fld", + [OP_POPBI_FLD_v6p] = {"", "popbi.fld", ev_pointer, ev_short, ev_field, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_FN] = {"", "popbi.fn", + [OP_POPBI_FN_v6p] = {"", "popbi.fn", ev_pointer, ev_short, ev_func, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_P] = {"", "popbi.p", + [OP_POPBI_P_v6p] = {"", "popbi.p", ev_pointer, ev_short, ev_pointer, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_Q] = {"", "popbi.q", + [OP_POPBI_Q_v6p] = {"", "popbi.q", ev_pointer, ev_short, ev_quat, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_I] = {"", "popbi.i", + [OP_POPBI_I_v6p] = {"", "popbi.i", ev_pointer, ev_short, ev_integer, PROG_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_D] = {"", "popbi.d", + [OP_POPBI_D_v6p] = {"", "popbi.d", ev_pointer, ev_short, ev_double, PROG_VERSION, "*(%Ga + %sb)", }, // end of table - [OP_MEMSETPI+1] = {0}, //XXX FIXME relies on OP_MEMSETPI being last + [OP_MEMSETPI_v6p+1] = {0}, //XXX FIXME relies on OP_MEMSETPI_v6p being last }; -const opcode_t * -PR_Opcode (pr_short_t opcode) +const v6p_opcode_t * +PR_v6p_Opcode (pr_ushort_t opcode) { - if (opcode < 0 - || opcode >= (int) (sizeof (pr_opcodes) / sizeof (pr_opcodes[0])) - 1) { + size_t opcode_count = sizeof (pr_v6p_opcodes) / sizeof (pr_v6p_opcodes[0]); + if (opcode >= opcode_count - 1) { return 0; } - return &pr_opcodes[opcode]; + return &pr_v6p_opcodes[opcode]; } VISIBLE void @@ -1528,7 +1528,7 @@ PR_Opcode_Init (void) } static inline void -check_branch (progs_t *pr, dstatement_t *st, const opcode_t *op, short offset) +check_branch (progs_t *pr, dstatement_t *st, const v6p_opcode_t *op, short offset) { pr_int_t address = st - pr->pr_statements; @@ -1544,7 +1544,7 @@ is_vector_parameter_store (progs_t *pr, dstatement_t *st, { int i; - if (st->op != OP_STORE_V) + if (st->op != OP_STORE_V_v6p) return 0; if (operand != st->a) return 0; @@ -1557,7 +1557,7 @@ is_vector_parameter_store (progs_t *pr, dstatement_t *st, #define ISDENORM(x) ((x) && !((x) & 0x7f800000)) static inline void -check_global (progs_t *pr, dstatement_t *st, const opcode_t *op, etype_t type, +check_global (progs_t *pr, dstatement_t *st, const v6p_opcode_t *op, etype_t type, unsigned short operand, int check_denorm) { const char *msg; @@ -1615,7 +1615,7 @@ error: } static void -check_global_size (progs_t *pr, dstatement_t *st, const opcode_t *op, +check_global_size (progs_t *pr, dstatement_t *st, const v6p_opcode_t *op, unsigned short size, unsigned short operand) { const char *msg; @@ -1633,7 +1633,7 @@ error: int PR_Check_Opcodes (progs_t *pr) { - const opcode_t *op; + const v6p_opcode_t *op; dstatement_t *st; int state_ok = 0; int pushpop_ok = 0; @@ -1653,13 +1653,13 @@ PR_Check_Opcodes (progs_t *pr) if (0 && !pr_boundscheck->int_val) { for (i = 0, st = pr->pr_statements; i < pr->progs->numstatements; st++, i++) { - op = PR_Opcode (st->op); + op = PR_v6p_Opcode (st->op); if (!op) { PR_Error (pr, "PR_Check_Opcodes: unknown opcode %d at " "statement %ld", st->op, (long)(st - pr->pr_statements)); } - if ((st->op == OP_STATE || st->op == OP_STATE_F) && !state_ok) { + if ((st->op == OP_STATE_v6p || st->op == OP_STATE_F_v6p) && !state_ok) { PR_Error (pr, "PR_Check_Opcodes: %s used with missing fields " "or globals", op->opname); } @@ -1672,43 +1672,43 @@ PR_Check_Opcodes (progs_t *pr) } else { for (i = 0, st = pr->pr_statements; i < pr->progs->numstatements; st++, i++) { - op = PR_Opcode (st->op); + op = PR_v6p_Opcode (st->op); if (!op) { PR_Error (pr, "PR_Check_Opcodes: unknown opcode %d at " "statement %ld", st->op, (long)(st - pr->pr_statements)); } switch (st->op) { - case OP_IF: - case OP_IFNOT: + case OP_IF_v6p: + case OP_IFNOT_v6p: check_global (pr, st, op, op->type_a, st->a, 1); check_branch (pr, st, op, st->b); break; - case OP_GOTO: + case OP_GOTO_v6p: check_branch (pr, st, op, st->a); break; - case OP_DONE: - case OP_RETURN: + case OP_DONE_v6p: + case OP_RETURN_v6p: check_global (pr, st, op, ev_integer, st->a, 1); check_global (pr, st, op, ev_void, st->b, 0); check_global (pr, st, op, ev_void, st->c, 0); break; - case OP_RCALL1: + case OP_RCALL1_v6p: check_global (pr, st, op, ev_void, st->c, 1); - case OP_RCALL2: - case OP_RCALL3: - case OP_RCALL4: - case OP_RCALL5: - case OP_RCALL6: - case OP_RCALL7: - case OP_RCALL8: - if (st->op > OP_RCALL1) + case OP_RCALL2_v6p: + case OP_RCALL3_v6p: + case OP_RCALL4_v6p: + case OP_RCALL5_v6p: + case OP_RCALL6_v6p: + case OP_RCALL7_v6p: + case OP_RCALL8_v6p: + if (st->op > OP_RCALL1_v6p) check_global (pr, st, op, ev_integer, st->c, 1); check_global (pr, st, op, ev_integer, st->b, 1); check_global (pr, st, op, ev_func, st->a, 1); break; - case OP_STATE: - case OP_STATE_F: + case OP_STATE_v6p: + case OP_STATE_F_v6p: if (!state_ok) { PR_Error (pr, "PR_Check_Opcodes: %s used with missing " "fields or globals", op->opname); @@ -1717,70 +1717,70 @@ PR_Check_Opcodes (progs_t *pr) check_global (pr, st, op, op->type_b, st->b, 1); check_global (pr, st, op, op->type_c, st->c, 1); break; - case OP_MOVEI: + case OP_MOVEI_v6p: check_global_size (pr, st, op, st->b, st->a); check_global_size (pr, st, op, st->b, st->c); break; - case OP_MEMSETI: + case OP_MEMSETI_v6p: check_global_size (pr, st, op, st->b, st->c); break; - case OP_PUSHB_F: - case OP_PUSHB_S: - case OP_PUSHB_ENT: - case OP_PUSHB_FLD: - case OP_PUSHB_FN: - case OP_PUSHB_I: - case OP_PUSHB_P: - case OP_PUSHB_V: - case OP_PUSHB_Q: - case OP_PUSHBI_F: - case OP_PUSHBI_S: - case OP_PUSHBI_ENT: - case OP_PUSHBI_FLD: - case OP_PUSHBI_FN: - case OP_PUSHBI_I: - case OP_PUSHBI_P: - case OP_PUSHBI_V: - case OP_PUSHBI_Q: + case OP_PUSHB_F_v6p: + case OP_PUSHB_S_v6p: + case OP_PUSHB_ENT_v6p: + case OP_PUSHB_FLD_v6p: + case OP_PUSHB_FN_v6p: + case OP_PUSHB_I_v6p: + case OP_PUSHB_P_v6p: + case OP_PUSHB_V_v6p: + case OP_PUSHB_Q_v6p: + case OP_PUSHBI_F_v6p: + case OP_PUSHBI_S_v6p: + case OP_PUSHBI_ENT_v6p: + case OP_PUSHBI_FLD_v6p: + case OP_PUSHBI_FN_v6p: + case OP_PUSHBI_I_v6p: + case OP_PUSHBI_P_v6p: + case OP_PUSHBI_V_v6p: + case OP_PUSHBI_Q_v6p: // op->type_c is used for selecting the operator during // compilation, but is invalid when running check_global (pr, st, op, op->type_a, st->a, 1); check_global (pr, st, op, op->type_b, st->b, 1); check_global (pr, st, op, ev_invalid, st->c, 1); break; - case OP_POP_F: - case OP_POP_FLD: - case OP_POP_ENT: - case OP_POP_S: - case OP_POP_FN: - case OP_POP_I: - case OP_POP_P: - case OP_POP_V: - case OP_POP_Q: + case OP_POP_F_v6p: + case OP_POP_FLD_v6p: + case OP_POP_ENT_v6p: + case OP_POP_S_v6p: + case OP_POP_FN_v6p: + case OP_POP_I_v6p: + case OP_POP_P_v6p: + case OP_POP_V_v6p: + case OP_POP_Q_v6p: // don't want to check for denormal floats, otherwise - // OP_POP_* could use the defualt rule + // OP_POP__v6p* could use the defualt rule check_global (pr, st, op, op->type_a, st->a, 0); check_global (pr, st, op, ev_invalid, st->b, 1); check_global (pr, st, op, ev_invalid, st->c, 1); break; - case OP_POPB_F: - case OP_POPB_S: - case OP_POPB_ENT: - case OP_POPB_FLD: - case OP_POPB_FN: - case OP_POPB_I: - case OP_POPB_P: - case OP_POPB_V: - case OP_POPB_Q: - case OP_POPBI_F: - case OP_POPBI_S: - case OP_POPBI_ENT: - case OP_POPBI_FLD: - case OP_POPBI_FN: - case OP_POPBI_I: - case OP_POPBI_P: - case OP_POPBI_V: - case OP_POPBI_Q: + case OP_POPB_F_v6p: + case OP_POPB_S_v6p: + case OP_POPB_ENT_v6p: + case OP_POPB_FLD_v6p: + case OP_POPB_FN_v6p: + case OP_POPB_I_v6p: + case OP_POPB_P_v6p: + case OP_POPB_V_v6p: + case OP_POPB_Q_v6p: + case OP_POPBI_F_v6p: + case OP_POPBI_S_v6p: + case OP_POPBI_ENT_v6p: + case OP_POPBI_FLD_v6p: + case OP_POPBI_FN_v6p: + case OP_POPBI_I_v6p: + case OP_POPBI_P_v6p: + case OP_POPBI_V_v6p: + case OP_POPBI_Q_v6p: // op->type_c is used for selecting the operator during // compilation, but is invalid when running check_global (pr, st, op, op->type_a, st->a, 1); @@ -1790,7 +1790,7 @@ PR_Check_Opcodes (progs_t *pr) default: check_global (pr, st, op, op->type_a, st->a, 1); check_global (pr, st, op, op->type_b, st->b, - (op - pr_opcodes) != OP_STORE_F); + (op - pr_v6p_opcodes) != OP_STORE_F_v6p); check_global (pr, st, op, op->type_c, st->c, 0); break; } diff --git a/tools/qfcc/include/opcodes.h b/tools/qfcc/include/opcodes.h index 2ffbe04c8..f6a95f75a 100644 --- a/tools/qfcc/include/opcodes.h +++ b/tools/qfcc/include/opcodes.h @@ -31,27 +31,28 @@ #ifndef __opcodes_h #define __opcodes_h -extern struct opcode_s *op_done; -extern struct opcode_s *op_return; -extern struct opcode_s *op_return_v; -extern struct opcode_s *op_if; -extern struct opcode_s *op_ifnot; -extern struct opcode_s *op_ifbe; -extern struct opcode_s *op_ifb; -extern struct opcode_s *op_ifae; -extern struct opcode_s *op_ifa; -extern struct opcode_s *op_state; -extern struct opcode_s *op_state_f; -extern struct opcode_s *op_goto; -extern struct opcode_s *op_jump; -extern struct opcode_s *op_jumpb; +extern struct v6p_opcode_s *op_done; +extern struct v6p_opcode_s *op_return; +extern struct v6p_opcode_s *op_return_v; +extern struct v6p_opcode_s *op_if; +extern struct v6p_opcode_s *op_ifnot; +extern struct v6p_opcode_s *op_ifbe; +extern struct v6p_opcode_s *op_ifb; +extern struct v6p_opcode_s *op_ifae; +extern struct v6p_opcode_s *op_ifa; +extern struct v6p_opcode_s *op_state; +extern struct v6p_opcode_s *op_state_f; +extern struct v6p_opcode_s *op_goto; +extern struct v6p_opcode_s *op_jump; +extern struct v6p_opcode_s *op_jumpb; struct operand_s; -extern struct opcode_s *opcode_map; +extern struct v6p_opcode_s *opcode_map; -struct opcode_s *opcode_find (const char *name, struct operand_s *op_a, - struct operand_s *op_b, struct operand_s *op_c); +struct v6p_opcode_s *opcode_find (const char *name, struct operand_s *op_a, + struct operand_s *op_b, + struct operand_s *op_c); void opcode_init (void); #endif//__opcodes_h diff --git a/tools/qfcc/source/emit.c b/tools/qfcc/source/emit.c index c2dac98ec..48e89b422 100644 --- a/tools/qfcc/source/emit.c +++ b/tools/qfcc/source/emit.c @@ -185,7 +185,7 @@ emit_statement (statement_t *statement) { const char *opcode = statement->opcode; def_t *def_a, *def_b, *def_c; - opcode_t *op; + v6p_opcode_t *op; dstatement_t *s; def_a = get_operand_def (statement->expr, statement->opa); diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index bf962ec96..8ad5358d9 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -49,14 +49,14 @@ hashtab_t *opcode_type_table; hashtab_t *opcode_void_table; -opcode_t *opcode_map; +v6p_opcode_t *opcode_map; #define ROTL(x,n) ((((unsigned)(x))<<(n))|((unsigned)(x))>>(32-n)) static uintptr_t get_hash (const void *_op, void *_tab) { - opcode_t *op = (opcode_t *) _op; + v6p_opcode_t *op = (v6p_opcode_t *) _op; uintptr_t hash; hash = ROTL (~op->type_a, 8) + ROTL (~op->type_b, 16) @@ -67,8 +67,8 @@ get_hash (const void *_op, void *_tab) static int compare (const void *_opa, const void *_opb, void *unused) { - opcode_t *opa = (opcode_t *) _opa; - opcode_t *opb = (opcode_t *) _opb; + v6p_opcode_t *opa = (v6p_opcode_t *) _opa; + v6p_opcode_t *opb = (v6p_opcode_t *) _opb; int cmp; cmp = (opa->type_a == opb->type_a) @@ -80,7 +80,7 @@ compare (const void *_opa, const void *_opb, void *unused) static const char * get_key (const void *op, void *unused) { - return ((opcode_t *) op)->name; + return ((v6p_opcode_t *) op)->name; } static int @@ -92,13 +92,13 @@ check_operand_type (etype_t ot1, etype_t ot2) return 0; } -opcode_t * +v6p_opcode_t * opcode_find (const char *name, operand_t *op_a, operand_t *op_b, operand_t *op_c) { - opcode_t search_op = {}; - opcode_t *op; - opcode_t *sop; + v6p_opcode_t search_op = {}; + v6p_opcode_t *op; + v6p_opcode_t *sop; void **op_list; int i; @@ -126,8 +126,8 @@ opcode_find (const char *name, operand_t *op_a, operand_t *op_b, void opcode_init (void) { - const opcode_t *op; - opcode_t *mop; + const v6p_opcode_t *op; + v6p_opcode_t *mop; if (opcode_type_table) { Hash_FlushTable (opcode_void_table); @@ -140,14 +140,14 @@ opcode_init (void) } int num_opcodes = 0; - for (op = pr_opcodes; op->name; op++) { + for (op = pr_v6p_opcodes; op->name; op++) { num_opcodes++; } if (!opcode_map) { - opcode_map = calloc (num_opcodes, sizeof (opcode_t)); + opcode_map = calloc (num_opcodes, sizeof (v6p_opcode_t)); } for (int i = 0; i < num_opcodes; i++) { - op = pr_opcodes + i; + op = pr_v6p_opcodes + i; if (op->min_version > options.code.progsversion) continue; mop = opcode_map + i; From 925797b1d459e5ac3ad67c7f92f7cac91c2cc677 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 2 Jan 2022 23:15:15 +0900 Subject: [PATCH 016/360] [gamecode] Add a new Ruamoko instruction set When it's finalized (most of the conversion operations will go, probably the float bit ops, maybe (very undecided) the 3-component vector ops, and likely the CALLN ops), this will be the actual instruction set for Ruamoko. Main features: - Significant reduction in redundant instructions: no more multiple opcodes to move the one operand size. - load, store, push, and pop share unified addressing mode encoding (with the exception of mode 0 for load as that is redundant with mode 0 for store, thus load mode 0 gives quick access to entity.field). - Full support for both 32 and 64 bit signed integer, unsigned integer, and floating point values. - SIMD for 1, 2, (currently) 3, and 4 components. Transfers support up to 128-bit wide operations (need two operations to transfer a full 4-component double/long vector), but all math operations support both 128-bit (32-bit components) and 256-bit (64-bit components) vectors. - "Interpreted" operations for the various vector sizes: complex dot and multiplication, 3d vector dot and cross product, quaternion dot and multiplication, along with qv and vq shortcuts. - 4-component swizzles for both sizes (not yet implemented, but the instructions are allocated), with the option to zero or negate (thus conjugates for complex and quaternion values) individual components. - "Based offsets": all relevant instructions include base register indices for all three operands allowing for direct access to any of four areas (eg, current entity, current stack frame, Objective-QC self, ...) instructions to set a register and push/pop the four registers to/from the stack. Remaining work: - Implement swizzle operations and a few other stragglers. = Make a decision about conversion operations (if any instructions remain, they'll be just single-component (at 14 meaningful pairs, that's a lot of instructions to waste on SIMD versions). - Decide whether to keep CALL1-CALL8: probably little point in supporting two different calling conventions, and it would free up another eight instructions. - Unit tests for the instructions. - Teach qfcc to generate code for the new instruction set (hah, biggest job, I'm sure, though hopefully not as crazy as the rewrite eleven years ago). --- include/QF/pr_comp.h | 184 +++++++- include/QF/progs.h | 3 + libs/gamecode/pr_exec.c | 919 ++++++++++++++++++++++++++++++++++++++ libs/gamecode/pr_opcode.c | 19 +- 4 files changed, 1116 insertions(+), 9 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index f51ce2693..84cc7e755 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -424,6 +424,188 @@ typedef enum { } pr_opcode_v6p_e; #define OP_BREAK 0x8000 +typedef enum { + // 0 0000 load from [a,b] -> c + OP_LOAD_E_1, OP_LOAD_E_2, OP_LOAD_E_3, OP_LOAD_E_4, + OP_LOAD_B_1, OP_LOAD_B_2, OP_LOAD_B_3, OP_LOAD_B_4, + OP_LOAD_C_1, OP_LOAD_C_2, OP_LOAD_C_3, OP_LOAD_C_4, + OP_LOAD_D_1, OP_LOAD_D_2, OP_LOAD_D_3, OP_LOAD_D_4, + // 0 0001 store from c -> [a, b] + OP_STORE_A_1, OP_STORE_A_2, OP_STORE_A_3, OP_STORE_A_4, // redundant? + OP_STORE_B_1, OP_STORE_B_2, OP_STORE_B_3, OP_STORE_B_4, + OP_STORE_C_1, OP_STORE_C_2, OP_STORE_C_3, OP_STORE_C_4, + OP_STORE_D_1, OP_STORE_D_2, OP_STORE_D_3, OP_STORE_D_4, + // 0 0010 push from [a,b] to the stack + OP_PUSH_A_1, OP_PUSH_A_2, OP_PUSH_A_3, OP_PUSH_A_4, + OP_PUSH_B_1, OP_PUSH_B_2, OP_PUSH_B_3, OP_PUSH_B_4, + OP_PUSH_C_1, OP_PUSH_C_2, OP_PUSH_C_3, OP_PUSH_C_4, + OP_PUSH_D_1, OP_PUSH_D_2, OP_PUSH_D_3, OP_PUSH_D_4, + // 0 0011 pop from the stack to [a,b] + OP_POP_A_1, OP_POP_A_2, OP_POP_A_3, OP_POP_A_4, + OP_POP_B_1, OP_POP_B_2, OP_POP_B_3, OP_POP_B_4, + OP_POP_C_1, OP_POP_C_2, OP_POP_C_3, OP_POP_C_4, + OP_POP_D_1, OP_POP_D_2, OP_POP_D_3, OP_POP_D_4, + // 0 0100 flow control + OP_IFNOT_A, OP_IFNOT_B, OP_IFNOT_C, OP_IFNOT_D, + OP_IF_A, OP_IF_B, OP_IF_C, OP_IF_D, + OP_JUMP_A, OP_JUMP_B, OP_JUMP_C, OP_JUMP_D, + OP_CALL_A, OP_CALL_B, OP_CALL_C, OP_CALL_D, + // 0 0101 calls + OP_CALL_1, OP_CALL_2, OP_CALL_3, OP_CALL_4, + OP_CALL_5, OP_CALL_6, OP_CALL_7, OP_CALL_8, + OP_RETURN_1, OP_RETURN_2, OP_RETURN_3, OP_RETURN_4, + OP_RETURN_0, OP_WITH, OP_STATE_ft, OP_STATE_ftt, + // 0 0110 flow control 2 + OP_IFA_A, OP_IFA_B, OP_IFA_C, OP_IFA_D, + OP_IFBE_A, OP_IFBE_B, OP_IFBE_C, OP_IFBE_D, + OP_IFB_A, OP_IFB_B, OP_IFB_C, OP_IFB_D, + OP_IFAE_A, OP_IFAE_B, OP_IFAE_C, OP_IFAE_D, + // 0 0111 interpreted vector multiplication + // C complex + // V vector (3d) + // Q quaternion + OP_DOT_CC_F, OP_DOT_VV_F, OP_DOT_QQ_F, OP_CROSS_VV_F, + OP_MUL_CC_F, OP_MUL_QV_F, OP_MUL_VQ_F, OP_MUL_QQ_F, + OP_DOT_CC_D, OP_DOT_VV_D, OP_DOT_QQ_D, OP_CROSS_VV_D, + OP_MUL_CC_D, OP_MUL_QV_D, OP_MUL_VQ_D, OP_MUL_QQ_D, + // comparison + // 0 1000 == + OP_EQ_I_1, OP_EQ_I_2, OP_EQ_I_3, OP_EQ_I_4, + OP_EQ_F_1, OP_EQ_F_2, OP_EQ_F_3, OP_EQ_F_4, + OP_EQ_L_1, OP_EQ_L_2, OP_EQ_L_3, OP_EQ_L_4, + OP_EQ_D_1, OP_EQ_D_2, OP_EQ_D_3, OP_EQ_D_4, + // 0 1001 < + OP_LT_I_1, OP_LT_I_2, OP_LT_I_3, OP_LT_I_4, + OP_LT_F_1, OP_LT_F_2, OP_LT_F_3, OP_LT_F_4, + OP_LT_L_1, OP_LT_L_2, OP_LT_L_3, OP_LT_L_4, + OP_LT_D_1, OP_LT_D_2, OP_LT_D_3, OP_LT_D_4, + // 0 1010 > + OP_GT_I_1, OP_GT_I_2, OP_GT_I_3, OP_GT_I_4, + OP_GT_F_1, OP_GT_F_2, OP_GT_F_3, OP_GT_F_4, + OP_GT_L_1, OP_GT_L_2, OP_GT_L_3, OP_GT_L_4, + OP_GT_D_1, OP_GT_D_2, OP_GT_D_3, OP_GT_D_4, + // 0 1011 convert between signed integral and double(XXX how useful as vec?) + OP_CONV_ID_1, OP_CONV_ID_2, OP_CONV_ID_3, OP_CONV_ID_4, + OP_CONV_DI_1, OP_CONV_DI_2, OP_CONV_DI_3, OP_CONV_DI_4, + OP_CONV_LD_1, OP_CONV_LD_2, OP_CONV_LD_3, OP_CONV_LD_4, + OP_CONV_DL_1, OP_CONV_DL_2, OP_CONV_DL_3, OP_CONV_DL_4, + // comparison + // 0 1100 != + OP_NE_I_1, OP_NE_I_2, OP_NE_I_3, OP_NE_I_4, + OP_NE_F_1, OP_NE_F_2, OP_NE_F_3, OP_NE_F_4, + OP_NE_L_1, OP_NE_L_2, OP_NE_L_3, OP_NE_L_4, + OP_NE_D_1, OP_NE_D_2, OP_NE_D_3, OP_NE_D_4, + // 0 1101 >= + OP_GE_I_1, OP_GE_I_2, OP_GE_I_3, OP_GE_I_4, + OP_GE_F_1, OP_GE_F_2, OP_GE_F_3, OP_GE_F_4, + OP_GE_L_1, OP_GE_L_2, OP_GE_L_3, OP_GE_L_4, + OP_GE_D_1, OP_GE_D_2, OP_GE_D_3, OP_GE_D_4, + // 0 1110 <= + OP_LE_I_1, OP_LE_I_2, OP_LE_I_3, OP_LE_I_4, + OP_LE_F_1, OP_LE_F_2, OP_LE_F_3, OP_LE_F_4, + OP_LE_L_1, OP_LE_L_2, OP_LE_L_3, OP_LE_L_4, + OP_LE_D_1, OP_LE_D_2, OP_LE_D_3, OP_LE_D_4, + // 0 1111 convert between signed integral sizes (XXX how useful as vec?) + OP_CONV_IL_1, OP_CONV_IL_2, OP_CONV_IL_3, OP_CONV_IL_4, + OP_CONV_LI_1, OP_CONV_LI_2, OP_CONV_LI_3, OP_CONV_LI_4, + OP_CONV_uU_1, OP_CONV_uU_2, OP_CONV_uU_3, OP_CONV_uU_4, + OP_CONV_Uu_1, OP_CONV_Uu_2, OP_CONV_Uu_3, OP_CONV_Uu_4, + + // 1 0000 c = a * b + OP_MUL_I_1, OP_MUL_I_2, OP_MUL_I_3, OP_MUL_I_4, + OP_MUL_F_1, OP_MUL_F_2, OP_MUL_F_3, OP_MUL_F_4, + OP_MUL_L_1, OP_MUL_L_2, OP_MUL_L_3, OP_MUL_L_4, + OP_MUL_D_1, OP_MUL_D_2, OP_MUL_D_3, OP_MUL_D_4, + // 1 0001 c = a / b + OP_DIV_I_1, OP_DIV_I_2, OP_DIV_I_3, OP_DIV_I_4, + OP_DIV_F_1, OP_DIV_F_2, OP_DIV_F_3, OP_DIV_F_4, + OP_DIV_L_1, OP_DIV_L_2, OP_DIV_L_3, OP_DIV_L_4, + OP_DIV_D_1, OP_DIV_D_2, OP_DIV_D_3, OP_DIV_D_4, + // 1 0010 c = a % b (remainder, C %) + OP_REM_I_1, OP_REM_I_2, OP_REM_I_3, OP_REM_I_4, + OP_REM_F_1, OP_REM_F_2, OP_REM_F_3, OP_REM_F_4, + OP_REM_L_1, OP_REM_L_2, OP_REM_L_3, OP_REM_L_4, + OP_REM_D_1, OP_REM_D_2, OP_REM_D_3, OP_REM_D_4, + // 1 0011 c = a %% b (true modulo, python %) + OP_MOD_I_1, OP_MOD_I_2, OP_MOD_I_3, OP_MOD_I_4, + OP_MOD_F_1, OP_MOD_F_2, OP_MOD_F_3, OP_MOD_F_4, + OP_MOD_L_1, OP_MOD_L_2, OP_MOD_L_3, OP_MOD_L_4, + OP_MOD_D_1, OP_MOD_D_2, OP_MOD_D_3, OP_MOD_D_4, + // 1 0100 c = a + b + OP_ADD_I_1, OP_ADD_I_2, OP_ADD_I_3, OP_ADD_I_4, + OP_ADD_F_1, OP_ADD_F_2, OP_ADD_F_3, OP_ADD_F_4, + OP_ADD_L_1, OP_ADD_L_2, OP_ADD_L_3, OP_ADD_L_4, + OP_ADD_D_1, OP_ADD_D_2, OP_ADD_D_3, OP_ADD_D_4, + // 1 0101 c = a - b + OP_SUB_I_1, OP_SUB_I_2, OP_SUB_I_3, OP_SUB_I_4, + OP_SUB_F_1, OP_SUB_F_2, OP_SUB_F_3, OP_SUB_F_4, + OP_SUB_L_1, OP_SUB_L_2, OP_SUB_L_3, OP_SUB_L_4, + OP_SUB_D_1, OP_SUB_D_2, OP_SUB_D_3, OP_SUB_D_4, + // 1 0110 c = a << b (string ops mixed in) + OP_SHL_I_1, OP_SHL_I_2, OP_SHL_I_3, OP_SHL_I_4, + OP_EQ_S, OP_LT_S, OP_GT_S, OP_ADD_S, + OP_SHL_L_1, OP_SHL_L_2, OP_SHL_L_3, OP_SHL_L_4, + OP_CMP_S, OP_GE_S, OP_LE_S, OP_NOT_S, //OP_CMP_S doubles as NE + // 1 0111 c = a >> b + OP_SHR_I_1, OP_SHR_I_2, OP_SHR_I_3, OP_SHR_I_4, + OP_SHR_u_1, OP_SHR_u_2, OP_SHR_u_3, OP_SHR_u_4, + OP_SHR_L_1, OP_SHR_L_2, OP_SHR_L_3, OP_SHR_L_4, + OP_SHR_U_1, OP_SHR_U_2, OP_SHR_U_3, OP_SHR_U_4, + // 1 1000 c = a (& | ^) b or ~a (bitwise ops) + OP_BITAND_I_1, OP_BITAND_I_2, OP_BITAND_I_3, OP_BITAND_I_4, + OP_BITOR_I_1, OP_BITOR_I_2, OP_BITOR_I_3, OP_BITOR_I_4, + OP_BITXOR_I_1, OP_BITXOR_I_2, OP_BITXOR_I_3, OP_BITXOR_I_4, + OP_BITNOT_I_1, OP_BITNOT_I_2, OP_BITNOT_I_3, OP_BITNOT_I_4, + // 1 1001 < unsigned (float logic and bit ops mixed in) + OP_LT_u_1, OP_LT_u_2, OP_LT_u_3, OP_LT_u_4, + OP_BITAND_F, OP_BITOR_F, OP_BITXOR_F, OP_BITNOT_F, + OP_LT_U_1, OP_LT_U_2, OP_LT_U_3, OP_LT_U_4, + OP_AND_F, OP_OR_F, OP_XOR_F, OP_NOT_F, + // 1 1010 > unsigned + OP_GT_u_1, OP_GT_u_2, OP_GT_u_3, OP_GT_u_4, + OP_spare, OP_NOT_D, OP_NOT_V, OP_NOT_Q, + OP_GT_U_1, OP_GT_U_2, OP_GT_U_3, OP_GT_U_4, + OP_EQ_V, OP_EQ_Q, OP_NE_V, OP_NE_Q, + // 1 1011 lea, with, etc + OP_LEA_A, OP_LEA_B, OP_LEA_C, OP_LEA_D, + OP_LEA_E, OP_ANY_2, OP_ANY_3, OP_ANY_4, + OP_PUSHREG, OP_ALL_2, OP_ALL_3, OP_ALL_4, + OP_POPREG, OP_NONE_2, OP_NONE_3, OP_NONE_4, + // 1 1100 c = a (&& || ^^) b or !a (logical ops (no short circuit)) + OP_AND_I_1, OP_AND_I_2, OP_AND_I_3, OP_AND_I_4, + OP_OR_I_1, OP_OR_I_2, OP_OR_I_3, OP_OR_I_4, + OP_XOR_I_1, OP_XOR_I_2, OP_XOR_I_3, OP_XOR_I_4, + OP_NOT_I_1, OP_NOT_I_2, OP_NOT_I_3, OP_NOT_I_4, + // 1 1101 >= unsigned with float shifts and moves mixed in + OP_GE_u_1, OP_GE_u_2, OP_GE_u_3, OP_GE_u_4, + OP_SHL_F, OP_MOVE_I, OP_MOVE_P, OP_MOVE_PI, + OP_GE_U_1, OP_GE_U_2, OP_GE_U_3, OP_GE_U_4, + OP_SHR_F, OP_MEMSET_I, OP_MEMSET_P, OP_MEMSET_PI, + // 1 1110 <= unsigned with scale and swizzle mixed in + OP_LE_u_1, OP_LE_u_2, OP_LE_u_3, OP_LE_u_4, + OP_SWIZZLE_F, OP_SCALE_F_2, OP_SCALE_F_3, OP_SCALE_F_4, + OP_LE_U_1, OP_LE_U_2, OP_LE_U_3, OP_LE_U_4, + OP_SWIZZLE_D, OP_SCALE_D_2, OP_SCALE_D_3, OP_SCALE_D_4, + // 1 1111 convert between integral and float (XXX how useful as vec?) + OP_CONV_IF_1, OP_CONV_IF_2, OP_CONV_IF_3, OP_CONV_IF_4, + OP_CONV_FI_1, OP_CONV_FI_2, OP_CONV_FI_3, OP_CONV_FI_4, + OP_CONV_FD_1, OP_CONV_FD_2, OP_CONV_FD_3, OP_CONV_FD_4, + OP_CONV_DF_1, OP_CONV_DF_2, OP_CONV_DF_3, OP_CONV_DF_4, +} pr_opcode_e; +#define OP_A_SHIFT (9) +#define OP_B_SHIFT (11) +#define OP_C_SHIFT (13) +#define OP_A_BASE (3 << OP_A_SHIFT) +#define OP_B_BASE (3 << OP_B_SHIFT) +#define OP_C_BASE (3 << OP_C_SHIFT) + +typedef enum { + OP_with_zero, + OP_with_base, + OP_with_stack, + OP_with_entity, +} pr_with_e; + typedef struct v6p_opcode_s { const char *name; const char *opname; @@ -437,7 +619,7 @@ const v6p_opcode_t *PR_v6p_Opcode (pr_ushort_t opcode) __attribute__((const)); void PR_Opcode_Init (void); // idempotent typedef struct dstatement_s { - pr_opcode_v6p_e op:16; + pr_opcode_e op:16; // will be pr_opcode_v6p_e for older progs pr_ushort_t a,b,c; } GCC_STRUCT dstatement_t; diff --git a/include/QF/progs.h b/include/QF/progs.h index 8d32e2074..6f3866ee1 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1793,6 +1793,8 @@ extern const char *pr_gametype; #define MAX_STACK_DEPTH 64 #define LOCALSTACK_SIZE 4096 #define PR_RS_SLOTS 16 +#define PR_BASE_IND(o, b) (((o) & OP_##b##_BASE) >> OP_##b##_SHIFT) +#define PR_BASE(p, s, b) (p->pr_bases[PR_BASE_IND(s->op, b)]) typedef struct strref_s strref_t; @@ -1876,6 +1878,7 @@ struct progs_s { dstatement_t *pr_statements; pr_type_t *pr_globals; unsigned globals_size; + pr_uivec4_t pr_bases; ///< base registers (index in opcode) ///@} /// \name parameter block diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index ae6b3df4e..3aa973620 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -44,6 +44,12 @@ #include "QF/sys.h" #include "QF/zone.h" +#include "QF/simd/vec2d.h" +#include "QF/simd/vec2f.h" +#include "QF/simd/vec2i.h" +#include "QF/simd/vec4d.h" +#include "QF/simd/vec4f.h" +#include "QF/simd/vec4i.h" #include "compat.h" @@ -1713,6 +1719,917 @@ op_call: exit_program: } +#define MM(type) (*((pr_##type##_t *) (mm))) +#define STK(type) (*((pr_##type##_t *) (stk))) + +static pr_type_t * +pr_entity_mode (progs_t *pr, const dstatement_t *st, int shift) +{ + pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); + pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, A); + int mm_ind = (st->op >> shift) & 3; + pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; + pointer_t mm_offs = 0; + + switch (mm_ind) { + case 0: + // entity.field (equivalent to OP_LOAD_t_v6p) + mm_offs = edict_area + OPA(uint) + OPB(uint); + break; + case 1: + // simple pointer dereference: *a + mm_offs = OPA(uint); + break; + case 2: + // constant indexed pointer: *a + b + mm_offs = OPA(uint) + st->b; + break; + case 3: + // verible indexed pointer: *a + *b (supports -ve offset) + mm_offs = OPA(uint) + OPB(int); + break; + } + return pr->pr_globals + mm_offs; +} + +static pr_type_t * +pr_address_mode (progs_t *pr, const dstatement_t *st, int shift) +{ + pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); + pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, A); + int mm_ind = (st->op >> shift) & 3; + pointer_t mm_offs = 0; + + switch (mm_ind) { + case 0: + // regular global access + mm_offs = op_a - pr->pr_globals; + break; + case 1: + // simple pointer dereference: *a + mm_offs = OPA(uint); + break; + case 2: + // constant indexed pointer: *a + b + mm_offs = OPA(uint) + st->b; + break; + case 3: + // verible indexed pointer: *a + *b (supports -ve offset) + mm_offs = OPA(uint) + OPB(int); + break; + } + return pr->pr_globals + mm_offs; +} + +static pr_pointer_t +pr_jump_mode (progs_t *pr, const dstatement_t *st) +{ + pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); + pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, A); + int jump_ind = st->op & 3; + pointer_t jump_offs = pr->pr_xstatement; + + switch (jump_ind) { + case 0: + // instruction relative offset + jump_offs = jump_offs + st->a; + break; + case 1: + // simple pointer dereference: *a + jump_offs = OPA(uint); + break; + case 2: + // constant indexed pointer: *a + b + jump_offs = OPA(uint) + st->b; + break; + case 3: + // verible indexed pointer: *a + *b (supports -ve offset) + jump_offs = OPA(uint) + OPB(int); + break; + } + return jump_offs - 1; // for st++ +} + +static pr_pointer_t __attribute__((pure)) +pr_with (progs_t *pr, const dstatement_t *st) +{ + pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, A); + pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; + switch (st->a) { + case 0: + // hard-0 base + return st->b; + case 1: + // relative to current base + return op_b - pr->pr_globals; + case 2: + // relative to stack (-ve offset) + return *pr->globals.stack + (pr_short_t) st->b; + case 3: + // relative to edict_area (+ve only) + return edict_area + st->b; + } + PR_RunError (pr, "Invalid with index: %u", st->a); +} + +static pr_type_t * +pr_stack_push (progs_t *pr) +{ + // keep the stack 16-byte aligned + pointer_t stack = *pr->globals.stack - 4; + pr_type_t *stk = pr->pr_globals + stack; + if (pr_boundscheck->int_val) { + check_stack_pointer (pr, stack, 4); + } + *pr->globals.stack = stack; + return stk; +} + +static pr_type_t * +pr_stack_pop (progs_t *pr) +{ + pointer_t stack = *pr->globals.stack; + pr_type_t *stk = pr->pr_globals + stack; + if (pr_boundscheck->int_val) { + check_stack_pointer (pr, stack, 4); + } + // keep the stack 16-byte aligned + *pr->globals.stack = stack + 4; + return stk; +} + +static void +pr_exec_ruamoko (progs_t *pr, int exitdepth) +{ + int profile, startprofile; + dstatement_t *st; + pr_type_t old_val = {0}; + + // make a stack frame + startprofile = profile = 0; + + st = pr->pr_statements + pr->pr_xstatement; + + if (pr->watch) { + old_val = *pr->watch; + } + + while (1) { + st++; + ++pr->pr_xstatement; + if (pr->pr_xstatement != st - pr->pr_statements) + PR_RunError (pr, "internal error"); + if (++profile > 1000000 && !pr->no_exec_limit) { + PR_RunError (pr, "runaway loop error"); + } + + if (pr->pr_trace) { + if (pr->debug_handler) { + pr->debug_handler (prd_trace, 0, pr->debug_data); + } else { + PR_PrintStatement (pr, st, 1); + } + } + + if (st->op & OP_BREAK) { + if (pr->debug_handler) { + pr->debug_handler (prd_breakpoint, 0, pr->debug_data); + } else { + PR_RunError (pr, "breakpoint hit"); + } + } + + pointer_t st_a = st->a + PR_BASE (pr, st, A); + pointer_t st_b = st->b + PR_BASE (pr, st, A); + pointer_t st_c = st->c + PR_BASE (pr, st, A); + + + pr_type_t *op_a = pr->pr_globals + st_a; + pr_type_t *op_b = pr->pr_globals + st_b; + pr_type_t *op_c = pr->pr_globals + st_c; + + pr_type_t *stk; + pr_type_t *mm; + func_t function; + pr_opcode_e st_op = st->op & ~(OP_BREAK|OP_A_BASE|OP_B_BASE|OP_C_BASE); + switch (st_op) { + // 0 0000 + case OP_LOAD_E_1: + case OP_LOAD_B_1: + case OP_LOAD_C_1: + case OP_LOAD_D_1: + mm = pr_entity_mode (pr, st, 2); + OPC(int) = MM(int); + break; + case OP_LOAD_E_2: + case OP_LOAD_B_2: + case OP_LOAD_C_2: + case OP_LOAD_D_2: + mm = pr_entity_mode (pr, st, 2); + OPC(ivec2) = MM(ivec2); + break; + case OP_LOAD_E_3: + case OP_LOAD_B_3: + case OP_LOAD_C_3: + case OP_LOAD_D_3: + mm = pr_entity_mode (pr, st, 2); + VectorCopy (&MM(int), &OPC(int)); + break; + case OP_LOAD_E_4: + case OP_LOAD_B_4: + case OP_LOAD_C_4: + case OP_LOAD_D_4: + mm = pr_entity_mode (pr, st, 2); + OPC(ivec4) = MM(ivec4); + break; + // 0 0001 + case OP_STORE_A_1: + case OP_STORE_B_1: + case OP_STORE_C_1: + case OP_STORE_D_1: + mm = pr_address_mode (pr, st, 2); + MM(int) = OPC(int); + break; + case OP_STORE_A_2: + case OP_STORE_B_2: + case OP_STORE_C_2: + case OP_STORE_D_2: + mm = pr_address_mode (pr, st, 2); + MM(ivec2) = OPC(ivec2); + break; + case OP_STORE_A_3: + case OP_STORE_B_3: + case OP_STORE_C_3: + case OP_STORE_D_3: + mm = pr_address_mode (pr, st, 2); + VectorCopy (&OPC(int), &MM(int)); + break; + case OP_STORE_A_4: + case OP_STORE_B_4: + case OP_STORE_C_4: + case OP_STORE_D_4: + mm = pr_address_mode (pr, st, 2); + MM(ivec4) = OPC(ivec4); + break; + // 0 0010 + case OP_PUSH_A_1: + case OP_PUSH_B_1: + case OP_PUSH_C_1: + case OP_PUSH_D_1: + mm = pr_address_mode (pr, st, 2); + stk = pr_stack_push (pr); + STK(int) = MM(int); + break; + case OP_PUSH_A_2: + case OP_PUSH_B_2: + case OP_PUSH_C_2: + case OP_PUSH_D_2: + mm = pr_address_mode (pr, st, 2); + stk = pr_stack_push (pr); + STK(ivec2) = MM(ivec2); + break; + case OP_PUSH_A_3: + case OP_PUSH_B_3: + case OP_PUSH_C_3: + case OP_PUSH_D_3: + mm = pr_address_mode (pr, st, 2); + stk = pr_stack_push (pr); + VectorCopy (&MM(int), &STK(int)); + break; + case OP_PUSH_A_4: + case OP_PUSH_B_4: + case OP_PUSH_C_4: + case OP_PUSH_D_4: + mm = pr_address_mode (pr, st, 2); + stk = pr_stack_push (pr); + STK(ivec4) = MM(ivec4); + break; + // 0 0011 + case OP_POP_A_1: + case OP_POP_B_1: + case OP_POP_C_1: + case OP_POP_D_1: + mm = pr_address_mode (pr, st, 2); + stk = pr_stack_pop (pr); + MM(int) = STK(int); + break; + case OP_POP_A_2: + case OP_POP_B_2: + case OP_POP_C_2: + case OP_POP_D_2: + mm = pr_address_mode (pr, st, 2); + stk = pr_stack_pop (pr); + MM(ivec2) = STK(ivec2); + break; + case OP_POP_A_3: + case OP_POP_B_3: + case OP_POP_C_3: + case OP_POP_D_3: + mm = pr_address_mode (pr, st, 2); + stk = pr_stack_pop (pr); + VectorCopy (&STK(int), &MM(int)); + break; + case OP_POP_A_4: + case OP_POP_B_4: + case OP_POP_C_4: + case OP_POP_D_4: + mm = pr_address_mode (pr, st, 2); + stk = pr_stack_pop (pr); + MM(ivec4) = STK(ivec4); + break; + // 0 0100 + case OP_IFNOT_A: + case OP_IFNOT_B: + case OP_IFNOT_C: + case OP_IFNOT_D: + if (!OPC(int)) { + pr->pr_xstatement = pr_jump_mode (pr, st); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_IF_A: + case OP_IF_B: + case OP_IF_C: + case OP_IF_D: + if (OPC(int)) { + pr->pr_xstatement = pr_jump_mode (pr, st); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_JUMP_A: + case OP_JUMP_B: + case OP_JUMP_C: + case OP_JUMP_D: + pr->pr_xstatement = pr_jump_mode (pr, st); + st = pr->pr_statements + pr->pr_xstatement; + break; + case OP_CALL_A: + case OP_CALL_B: + case OP_CALL_C: + case OP_CALL_D: + mm = pr_address_mode (pr, st, 0); + function = mm->func_var; + pr->pr_argc = 0; + op_call: + pr->pr_xfunction->profile += profile - startprofile; + startprofile = profile; + PR_CallFunction (pr, function); + st = pr->pr_statements + pr->pr_xstatement; + break; + // 0 0101 + case OP_CALL_2: case OP_CALL_3: case OP_CALL_4: + case OP_CALL_5: case OP_CALL_6: case OP_CALL_7: case OP_CALL_8: + pr->pr_params[1] = op_c; + goto op_call_n; + case OP_CALL_1: + pr->pr_params[1] = pr->pr_real_params[1]; + op_call_n: + pr->pr_params[0] = op_b; + function = op_a->func_var; + pr->pr_argc = st->op - OP_CALL_1 + 1; + goto op_call; + case OP_RETURN_4: + memcpy (&R_INT (pr), op_a, 4 * sizeof (*op_a)); + goto op_return; + case OP_RETURN_3: + memcpy (&R_INT (pr), op_a, 3 * sizeof (*op_a)); + goto op_return; + case OP_RETURN_2: + memcpy (&R_INT (pr), op_a, 2 * sizeof (*op_a)); + goto op_return; + case OP_RETURN_1: + memcpy (&R_INT (pr), op_a, 1 * sizeof (*op_a)); + goto op_return; + case OP_RETURN_0: + op_return: + pr->pr_xfunction->profile += profile - startprofile; + startprofile = profile; + PR_LeaveFunction (pr, pr->pr_depth == exitdepth); + st = pr->pr_statements + pr->pr_xstatement; + if (pr->pr_depth== exitdepth) { + if (pr->pr_trace && pr->pr_depth <= pr->pr_trace_depth) { + pr->pr_trace = false; + } + goto exit_program; + } + break; + case OP_WITH: + pr->pr_bases[st->c] = pr_with (pr, st); + break; + case OP_STATE_ft: + { + int self = *pr->globals.self; + int nextthink = pr->fields.nextthink + self; + int frame = pr->fields.frame + self; + int think = pr->fields.think + self; + float time = *pr->globals.time + 0.1; + pr->pr_edict_area[nextthink].float_var = time; + pr->pr_edict_area[frame].float_var = OPA(float); + pr->pr_edict_area[think].func_var = op_b->func_var; + } + break; + case OP_STATE_ftt: + { + int self = *pr->globals.self; + int nextthink = pr->fields.nextthink + self; + int frame = pr->fields.frame + self; + int think = pr->fields.think + self; + float time = *pr->globals.time + OPC(float); + pr->pr_edict_area[nextthink].float_var = time; + pr->pr_edict_area[frame].float_var = OPA(float); + pr->pr_edict_area[think].func_var = op_b->func_var; + } + break; + // 0 0110 + case OP_IFA_A: + case OP_IFA_B: + case OP_IFA_C: + case OP_IFA_D: + if (OPC(int) > 0) { + pr->pr_xstatement = pr_jump_mode (pr, st); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_IFBE_A: + case OP_IFBE_B: + case OP_IFBE_C: + case OP_IFBE_D: + if (OPC(int) <= 0) { + pr->pr_xstatement = pr_jump_mode (pr, st); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_IFB_A: + case OP_IFB_B: + case OP_IFB_C: + case OP_IFB_D: + if (OPC(int) < 0) { + pr->pr_xstatement = pr_jump_mode (pr, st); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_IFAE_A: + case OP_IFAE_B: + case OP_IFAE_C: + case OP_IFAE_D: + if (OPC(int) >= 0) { + pr->pr_xstatement = pr_jump_mode (pr, st); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + // 0 0111 + case OP_DOT_CC_F: + OPC(vec2) = dot2f (OPA(vec2), OPB(vec2)); + break; + case OP_DOT_VV_F: + { + vec_t d = DotProduct (&OPA(float), + &OPB(float)); + VectorSet (d, d, d, &OPC(float)); + } + break; + case OP_DOT_QQ_F: + OPC(vec4) = dotf (OPA(vec4), OPB(vec4)); + break; + case OP_CROSS_VV_F: + { + pr_vec4_t a = loadvec3f (&OPA(float)); + pr_vec4_t b = loadvec3f (&OPB(float)); + pr_vec4_t c = crossf (a, b); + storevec3f (&OPC(float), c); + } + break; + case OP_MUL_CC_F: + OPC(vec2) = cmulf (OPA(vec2), OPB(vec2)); + break; + case OP_MUL_QV_F: + { + pr_vec4_t v = loadvec3f (&OPB(float)); + v = qvmulf (OPA(vec4), v); + storevec3f (&OPC(float), v); + } + break; + case OP_MUL_VQ_F: + { + pr_vec4_t v = loadvec3f (&OPA(float)); + v = vqmulf (v, OPB(vec4)); + storevec3f (&OPC(float), v); + } + break; + case OP_MUL_QQ_F: + OPC(vec4) = qmulf (OPA(vec4), OPB(vec4)); + break; + case OP_DOT_CC_D: + OPC(dvec2) = dot2d (OPA(dvec2), OPB(dvec2)); + break; + case OP_DOT_VV_D: + { + double d = DotProduct (&OPA(double), + &OPB(double)); + VectorSet (d, d, d, &OPC(double)); + } + break; + case OP_DOT_QQ_D: + OPC(dvec4) = dotd (OPA(dvec4), OPB(dvec4)); + break; + case OP_CROSS_VV_D: + { + pr_dvec4_t a = loadvec3d (&OPA(double)); + pr_dvec4_t b = loadvec3d (&OPB(double)); + pr_dvec4_t c = crossd (a, b); + storevec3d (&OPC(double), c); + } + break; + case OP_MUL_CC_D: + OPC(dvec2) = cmuld (OPA(dvec2), OPB(dvec2)); + break; + case OP_MUL_QV_D: + { + pr_dvec4_t v = loadvec3d (&OPB(double)); + v = qvmuld (OPA(dvec4), v); + storevec3d (&OPC(double), v); + } + break; + case OP_MUL_VQ_D: + { + pr_dvec4_t v = loadvec3d (&OPA(double)); + v = vqmuld (v, OPB(dvec4)); + storevec3d (&OPC(double), v); + } + break; + case OP_MUL_QQ_D: + OPC(dvec4) = qmuld (OPA(dvec4), OPB(dvec4)); + break; + +#define OP_cmp_1(OP, T, rt, cmp, ct) \ + case OP_##OP##_##T##_1: \ + OPC(rt) = -(OPA(ct) cmp OPB(ct)); \ + break +#define OP_cmp_2(OP, T, rt, cmp, ct) \ + case OP_##OP##_##T##_2: \ + OPC(rt) = (OPA(ct) cmp OPB(ct)); \ + break +#define OP_cmp_3(OP, T, rt, cmp, ct) \ + case OP_##OP##_##T##_3: \ + VectorCompCompare (&OPC(rt), -, &OPA(ct), cmp, &OPB(ct)); \ + break; +#define OP_cmp_4(OP, T, rt, cmp, ct) \ + case OP_##OP##_##T##_4: \ + OPC(rt) = (OPA(ct) cmp OPB(ct)); \ + break +#define OP_cmp_T(OP, T, rt1, rt2, rt4, cmp, ct1, ct2, ct4) \ + OP_cmp_1 (OP, T, rt1, cmp, ct1); \ + OP_cmp_2 (OP, T, rt2, cmp, ct2); \ + OP_cmp_3 (OP, T, rt1, cmp, ct1); \ + OP_cmp_4 (OP, T, rt4, cmp, ct4) +#define OP_cmp(OP, cmp) \ + OP_cmp_T (OP, I, int, ivec2, ivec4, cmp, int, ivec2, ivec4); \ + OP_cmp_T (OP, F, int, ivec2, ivec4, cmp, float, vec2, vec4); \ + OP_cmp_T (OP, L, long, lvec2, lvec4, cmp, long, lvec2, lvec4); \ + OP_cmp_T (OP, D, long, lvec2, lvec4, cmp, double, dvec2, dvec4) + + // 0 1000 + OP_cmp(EQ, ==); + // 0 1001 + OP_cmp(LT, <); + // 0 1010 + OP_cmp(GT, >); + // 0 1011 + //FIXME conversion 1 + // 0 1100 + OP_cmp(NE, !=); + // 0 1101 + OP_cmp(GE, >=); + // 0 1110 + OP_cmp(LE, <=); + // 0 1011 + //FIXME conversion 2 + +#define OP_op_1(OP, T, t, op) \ + case OP_##OP##_##T##_1: \ + OPC(t) = (OPA(t) op OPB(t)); \ + break +#define OP_op_2(OP, T, t, op) \ + case OP_##OP##_##T##_2: \ + OPC(t) = (OPA(t) op OPB(t)); \ + break +#define OP_op_3(OP, T, t, op) \ + case OP_##OP##_##T##_3: \ + VectorCompOp (&OPC(t), &OPA(t), op, &OPB(t)); \ + break; +#define OP_op_4(OP, T, t, op) \ + case OP_##OP##_##T##_4: \ + OPC(t) = (OPA(t) op OPB(t)); \ + break +#define OP_op_T(OP, T, t1, t2, t4, op) \ + OP_op_1 (OP, T, t1, op); \ + OP_op_2 (OP, T, t2, op); \ + OP_op_3 (OP, T, t1, op); \ + OP_op_4 (OP, T, t4, op) +#define OP_op(OP, op) \ + OP_op_T (OP, I, int, ivec2, ivec4, op); \ + OP_op_T (OP, F, float, vec2, vec4, op); \ + OP_op_T (OP, L, long, lvec2, lvec4, op); \ + OP_op_T (OP, D, double, dvec2, dvec4, op) +#define OP_uop_1(OP, T, t, op) \ + case OP_##OP##_##T##_1: \ + OPC(t) = op (OPA(t)); \ + break +#define OP_uop_2(OP, T, t, op) \ + case OP_##OP##_##T##_2: \ + OPC(t) = op (OPA(t)); \ + break +#define OP_uop_3(OP, T, t, op) \ + case OP_##OP##_##T##_3: \ + VectorCompUop (&OPC(t), op, &OPA(t)); \ + break; +#define OP_uop_4(OP, T, t, op) \ + case OP_##OP##_##T##_4: \ + OPC(t) = op (OPA(t)); \ + break +#define OP_uop_T(OP, T, t1, t2, t4, op) \ + OP_uop_1 (OP, T, t1, op); \ + OP_uop_2 (OP, T, t2, op); \ + OP_uop_3 (OP, T, t1, op); \ + OP_uop_4 (OP, T, t4, op) + + // 1 0000 + OP_op(MUL, *); + // 1 0001 + OP_op(DIV, /); + +#define OP_store(d, s) *(d) = s +#define OP_remmod_T(OP, T, n, t, l, f, s) \ + case OP_##OP##_##T##_##n: \ + { \ + __auto_type a = l (&OPA(t)); \ + __auto_type b = l (&OPB(t)); \ + s (&OPC(t), a - b * f(a / b)); \ + } \ + break +#define OP_rem_T(T, n, t, l, f, s) \ + OP_remmod_T(REM, T, n, t, l, f, s) + + // 1 0010 + OP_op_T (REM, I, int, ivec2, ivec4, %); + OP_rem_T (F, 1, float, *, truncf, OP_store); + OP_rem_T (F, 2, vec2, *, vtrunc2f, OP_store); + OP_rem_T (F, 3, float, loadvec3f, vtrunc4f, storevec3f); + OP_rem_T (F, 4, vec4, *, vtrunc4f, OP_store); + OP_op_T (REM, L, long, lvec2, lvec4, %); + OP_rem_T (D, 1, double, *, trunc, OP_store); + OP_rem_T (D, 2, dvec2, *, vtrunc2d, OP_store); + OP_rem_T (D, 3, double, loadvec3d, vtrunc4d, storevec3d); + OP_rem_T (D, 4, dvec4, *, vtrunc4d, OP_store); + +// implement true modulo for integers: +// 5 mod 3 = 2 +// -5 mod 3 = 1 +// 5 mod -3 = -1 +// -5 mod -3 = -2 +#define OP_mod_Ti(T, n, t, l, m, s) \ + case OP_MOD_##T##_##n: \ + { \ + __auto_type a = l(&OPA(t)); \ + __auto_type b = l(&OPB(t)); \ + __auto_type c = a % b; \ + /* % is really remainder and so has the same sign rules */\ + /* as division: -5 % 3 = -2, so need to add b (3 here) */\ + /* if c's sign is incorrect, but only if c is non-zero */\ + __auto_type mask = m((a ^ b) < 0); \ + mask &= m(c != 0); \ + s(&OPC(t), c + (mask & b)); \ + } \ + break +// floating point modulo is so much easier :P (just use floor instead of trunc) +#define OP_mod_Tf(T, n, t, l, f, s) \ + OP_remmod_T(MOD, T, n, t, l, f, s) + + // 1 0011 + OP_mod_Ti (I, 1, int, *, -, OP_store); + OP_mod_Ti (I, 2, ivec2, *, +, OP_store); + OP_mod_Ti (I, 3, int, loadvec3i, +, storevec3i); + OP_mod_Ti (I, 4, ivec4, *, +, OP_store); + OP_mod_Tf (F, 1, float, *, floorf, OP_store); + OP_mod_Tf (F, 2, vec2, *, vfloor2f, OP_store); + OP_mod_Tf (F, 3, float, loadvec3f, vfloor4f, storevec3f); + OP_mod_Tf (F, 4, vec4, *, vfloor4f, OP_store); + OP_mod_Ti (L, 1, long, *, -, OP_store); + OP_mod_Ti (L, 2, ivec2, *, +, OP_store); + OP_mod_Ti (L, 3, long, loadvec3l, +, storevec3l); + OP_mod_Ti (L, 4, ivec4, *, +, OP_store); + OP_mod_Tf (D, 1, double, *, floor, OP_store); + OP_mod_Tf (D, 2, dvec2, *, vfloor2d, OP_store); + OP_mod_Tf (D, 3, double, loadvec3d, vfloor4d, storevec3d); + OP_mod_Tf (D, 4, dvec4, *, vfloor4d, OP_store); + + // 1 0100 + OP_op(ADD, +); + // 1 0101 + OP_op(SUB, -); + // 1 0110 + OP_op_T (SHL, I, int, ivec2, ivec4, <<); + OP_op_T (SHL, L, long, lvec2, lvec4, <<); + case OP_EQ_S: + case OP_LT_S: + case OP_GT_S: + case OP_CMP_S: + case OP_GE_S: + case OP_LE_S: + { + int cmp = strcmp (PR_GetString (pr, OPA(string)), + PR_GetString (pr, OPB(string))); + switch (st_op) { + case OP_EQ_S: cmp = (cmp == 0); break; + case OP_LT_S: cmp = (cmp < 0); break; + case OP_GT_S: cmp = (cmp > 0); break; + case OP_GE_S: cmp = (cmp >= 0); break; + case OP_LE_S: cmp = (cmp <= 0); break; + case OP_NOT_S: break; + default: break; + } + OPC(int) = cmp; + } + break; + case OP_ADD_S: + OPC(string) = PR_CatStrings(pr, PR_GetString (pr, OPA(string)), + PR_GetString (pr, OPB(string))); + break; + case OP_NOT_S: + OPC(int) = !OPA(string) || !*PR_GetString (pr, OPA(string)); + break; + // 1 0111 + OP_op_T (SHR, I, int, ivec2, ivec4, >>); + OP_op_T (SHR, u, uint, uivec2, uivec4, >>); + OP_op_T (SHR, L, long, lvec2, lvec4, >>); + OP_op_T (SHR, U, ulong, ulvec2, ulvec4, >>); + // 1 1000 + OP_op_T (BITAND, I, int, ivec2, ivec4, &); + OP_op_T (BITOR, I, int, ivec2, ivec4, |); + OP_op_T (BITXOR, I, int, ivec2, ivec4, ^); + OP_uop_T (BITNOT, I, int, ivec2, ivec4, ~); + // 1 1001 + OP_op_T (LT, u, uint, uivec2, uivec4, <); + //FIXME float ops + OP_op_T (LT, U, ulong, ulvec2, ulvec4, <); + //FIXME float ops + // 1 1010 + OP_op_T (GT, u, uint, uivec2, uivec4, >); + //FIXME misc ops + OP_op_T (GT, U, ulong, ulvec2, ulvec4, >); + //FIXME misc ops + // 1 1011 + case OP_LEA_A: + case OP_LEA_B: + case OP_LEA_C: + case OP_LEA_D: + mm = pr_address_mode (pr, st, 0); + op_c->pointer_var = mm - pr->pr_globals; + break; + case OP_LEA_E: + // ensures OP_LEA_E is compatible with OP_LOAD_E_n and thus + // with pr_entity_mode + mm = __builtin_choose_expr ( + (OP_LEA_E & 3) == 0, + pr_entity_mode (pr, st, 0), + (void) 0); + op_c->pointer_var = mm - pr->pr_globals; + break; + case OP_ANY_2: + OPC(int) = any2i (OPA(ivec2)); + break; + case OP_ANY_3: + { + __auto_type v = loadvec3i (&OPA(int)); + OPC(int) = any4i (v); + } + break; + case OP_ANY_4: + OPC(int) = any4i (OPA(ivec4)); + break; + case OP_PUSHREG: + stk = pr_stack_push (pr); + STK(uivec4) = pr->pr_bases; + break; + case OP_ALL_2: + OPC(int) = all2i (OPA(ivec2)); + break; + case OP_ALL_3: + { + __auto_type v = loadvec3i (&OPA(int)); + v[3] = -1; + OPC(int) = all4i (v); + } + break; + case OP_ALL_4: + OPC(int) = all4i (OPA(ivec4)); + break; + case OP_POPREG: + stk = pr_stack_pop (pr); + pr->pr_bases = STK(uivec4); + break; + case OP_NONE_2: + OPC(int) = none2i (OPA(ivec2)); + break; + case OP_NONE_3: + { + __auto_type v = loadvec3i (&OPA(int)); + OPC(int) = none4i (v); + } + break; + case OP_NONE_4: + OPC(int) = none4i (OPA(ivec4)); + break; + +#define OP_bool_n(OP, t, n, op, m) \ + case OP_##OP##_I_##n: \ + OPC(t) = m((OPA(t) != 0) op (OPB(t) != 0)); \ + break +#define OP_bool_3(OP, t, n, op, m) \ + case OP_##OP##_I_##n: \ + { \ + __auto_type a = loadvec3i (&OPA(int)); \ + __auto_type b = loadvec3i (&OPB(int)); \ + storevec3i (&OPC(int), (a != 0) op (b != 0)); \ + } \ + break +#define OP_bool(OP, op) \ + OP_bool_n (OP, int, 1, op, -); \ + OP_bool_n (OP, ivec2, 2, op, +); \ + OP_bool_3 (OP, int, 3, op, +); \ + OP_bool_n (OP, ivec4, 4, op, +) +#define OP_not_n(OP, t, n, m) \ + case OP_##OP##_I_##n: \ + OPC(t) = m((OPA(t) == 0)); \ + break +#define OP_not_3(OP, t, n, m) \ + case OP_##OP##_I_##n: \ + { \ + __auto_type a = loadvec3i (&OPA(int)); \ + storevec3i (&OPC(int), (a == 0)); \ + } \ + break + // 1 1100 + OP_bool (AND, &); + OP_bool (OR, |); + OP_bool (XOR, ^); + OP_not_n (NOT, int, 1, -); + OP_not_n (NOT, ivec2, 2, +); + OP_not_3 (NOT, int, 3, +); + OP_not_n (NOT, ivec4, 4, +); + // 1 1101 + OP_op_T (GE, u, uint, uivec2, uivec4, >=); + //FIXME float shift + case OP_MOVE_I: + memmove (op_c, op_a, st->b * sizeof (pr_type_t)); + break; + case OP_MOVE_P: + memmove (pr->pr_globals + OPC(int), pr->pr_globals + OPA(int), + OPB(uint) * sizeof (pr_type_t)); + break; + case OP_MOVE_PI: + memmove (pr->pr_globals + OPC(int), pr->pr_globals + OPA(int), + st->b * sizeof (pr_type_t)); + break; + OP_op_T (GE, U, ulong, ulvec2, ulvec4, >=); + //FIXME float shift + case OP_MEMSET_I: + memset (op_c, OPA(int), st->b * sizeof (pr_type_t)); + break; + case OP_MEMSET_P: + memset (pr->pr_globals + OPC(int), OPA(int), + OPB(uint) * sizeof (pr_type_t)); + break; + case OP_MEMSET_PI: + memset (pr->pr_globals + OPC(int), OPA(int), + st->b * sizeof (pr_type_t)); + break; + // 1 1110 + OP_op_T (LE, u, uint, uivec2, uivec4, <=); + //FIXME misc ops + OP_op_T (LE, U, ulong, ulvec2, ulvec4, <=); + //FIXME misc ops + // 1 1111 + //FIXME conversion 3 + + default: + PR_RunError (pr, "Bad opcode %i", st->op); + } + if (pr->watch && pr->watch->integer_var != old_val.integer_var) { + if (!pr->wp_conditional + || pr->watch->integer_var == pr->wp_val.integer_var) { + if (pr->debug_handler) { + pr->debug_handler (prd_watchpoint, 0, pr->debug_data); + } else { + PR_RunError (pr, "watchpoint hit: %d -> %d", + old_val.integer_var, pr->watch->integer_var); + } + } + old_val.integer_var = pr->watch->integer_var; + } + } +exit_program: +} /* PR_ExecuteProgram @@ -1735,6 +2652,8 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum) } if (1) { pr_exec_quakec (pr, exitdepth); + } else { + pr_exec_ruamoko (pr, exitdepth); } exit_program: if (pr->debug_handler) { diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index 17d640575..f2710d446 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -1544,7 +1544,7 @@ is_vector_parameter_store (progs_t *pr, dstatement_t *st, { int i; - if (st->op != OP_STORE_V_v6p) + if ((pr_opcode_v6p_e) st->op != OP_STORE_V_v6p) return 0; if (operand != st->a) return 0; @@ -1653,13 +1653,15 @@ PR_Check_Opcodes (progs_t *pr) if (0 && !pr_boundscheck->int_val) { for (i = 0, st = pr->pr_statements; i < pr->progs->numstatements; st++, i++) { - op = PR_v6p_Opcode (st->op); + pr_opcode_v6p_e st_op = st->op; + op = PR_v6p_Opcode (st_op); if (!op) { PR_Error (pr, "PR_Check_Opcodes: unknown opcode %d at " - "statement %ld", st->op, + "statement %ld", st_op, (long)(st - pr->pr_statements)); } - if ((st->op == OP_STATE_v6p || st->op == OP_STATE_F_v6p) && !state_ok) { + if ((st_op == OP_STATE_v6p || st_op == OP_STATE_F_v6p) + && !state_ok) { PR_Error (pr, "PR_Check_Opcodes: %s used with missing fields " "or globals", op->opname); } @@ -1672,13 +1674,14 @@ PR_Check_Opcodes (progs_t *pr) } else { for (i = 0, st = pr->pr_statements; i < pr->progs->numstatements; st++, i++) { - op = PR_v6p_Opcode (st->op); + pr_opcode_v6p_e st_op = st->op; + op = PR_v6p_Opcode (st_op); if (!op) { PR_Error (pr, "PR_Check_Opcodes: unknown opcode %d at " - "statement %ld", st->op, + "statement %ld", st_op, (long)(st - pr->pr_statements)); } - switch (st->op) { + switch (st_op) { case OP_IF_v6p: case OP_IFNOT_v6p: check_global (pr, st, op, op->type_a, st->a, 1); @@ -1702,7 +1705,7 @@ PR_Check_Opcodes (progs_t *pr) case OP_RCALL6_v6p: case OP_RCALL7_v6p: case OP_RCALL8_v6p: - if (st->op > OP_RCALL1_v6p) + if (st_op > OP_RCALL1_v6p) check_global (pr, st, op, ev_integer, st->c, 1); check_global (pr, st, op, ev_integer, st->b, 1); check_global (pr, st, op, ev_func, st->a, 1); From 8a2788c267ca76eb31d1f76bc0181d27ed560b26 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 13:56:43 +0900 Subject: [PATCH 017/360] [gamecode] Add PROG_V6P_VERSION and bump PROG_VERSION This allows the VM to select the right execution loop and qfcc currently still produces only the old IS (it doesn't know how to deal with the new IS yet) --- include/QF/pr_comp.h | 3 +- libs/gamecode/pr_exec.c | 2 +- libs/gamecode/pr_load.c | 1 + libs/gamecode/pr_opcode.c | 442 ++++++++++++++++++------------------ libs/gamecode/pr_strings.c | 5 +- tools/qfcc/source/options.c | 6 +- tools/qfcc/source/pragma.c | 2 +- 7 files changed, 233 insertions(+), 228 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index 84cc7e755..df81d606f 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -693,7 +693,8 @@ typedef struct pr_va_list_s { |(((0x##b) & 0xfff) << 12) \ |(((0x##c) & 0xfff) << 0) ) #define PROG_ID_VERSION 6 -#define PROG_VERSION PROG_VERSION_ENCODE(0,fff,00a) +#define PROG_V6P_VERSION PROG_VERSION_ENCODE(0,fff,00a) +#define PROG_VERSION PROG_VERSION_ENCODE(0,fff,010) typedef struct dprograms_s { pr_uint_t version; diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 3aa973620..ad5808107 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -2650,7 +2650,7 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum) // called a builtin instead of progs code goto exit_program; } - if (1) { + if (pr->progs->version < PROG_VERSION) { pr_exec_quakec (pr, exitdepth); } else { pr_exec_ruamoko (pr, exitdepth); diff --git a/libs/gamecode/pr_load.c b/libs/gamecode/pr_load.c index 40f99dd84..95626fc22 100644 --- a/libs/gamecode/pr_load.c +++ b/libs/gamecode/pr_load.c @@ -145,6 +145,7 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) ((int *) &progs)[i] = LittleLong (((int *) &progs)[i]); if (progs.version != PROG_VERSION + && progs.version != PROG_V6P_VERSION && progs.version != PROG_ID_VERSION) { if (progs.version < 0x00fff000) { PR_Error (pr, "%s has unrecognised version number (%u)", diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index f2710d446..aff4784de 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -105,7 +105,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { [OP_MUL_D_v6p] = {"*", "mul.d", ev_double, ev_double, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_MUL_F_v6p] = {"*", "mul.f", ev_float, ev_float, ev_float, @@ -133,32 +133,32 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_MUL_Q_v6p] = {"*", "mul.q", ev_quat, ev_quat, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_MUL_FQ_v6p] = {"*", "mul.fq", ev_float, ev_quat, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_MUL_QF_v6p] = {"*", "mul.qf", ev_quat, ev_float, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_MUL_DQ_v6p] = {"*", "mul.dq", ev_double, ev_quat, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_MUL_QD_v6p] = {"*", "mul.qd", ev_quat, ev_double, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_MUL_QV_v6p] = {"*", "mul.qv", ev_quat, ev_vector, ev_vector, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_CONJ_Q_v6p] = {"~", "conj.q", ev_quat, ev_invalid, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, @@ -168,20 +168,20 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_DIV_D_v6p] = {"/", "div.d", ev_double, ev_double, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_REM_D_v6p] = {"%", "rem.d", ev_double, ev_double, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_MOD_D_v6p] = {"%%", "mod.d", ev_double, ev_double, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_ADD_D_v6p] = {"+", "add.d", ev_double, ev_double, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_ADD_F_v6p] = {"+", "add.f", ev_float, ev_float, ev_float, @@ -193,16 +193,16 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_ADD_Q_v6p] = {"+", "add.q", ev_quat, ev_quat, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_ADD_S_v6p] = {"+", "add.s", ev_string, ev_string, ev_string, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_SUB_D_v6p] = {"-", "sub.d", ev_double, ev_double, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_SUB_F_v6p] = {"-", "sub.f", ev_float, ev_float, ev_float, @@ -214,12 +214,12 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_SUB_Q_v6p] = {"-", "sub.q", ev_quat, ev_quat, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_EQ_D_v6p] = {"==", "eq.d", ev_double, ev_double, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_EQ_F_v6p] = {"==", "eq.f", ev_float, ev_float, ev_integer, @@ -231,7 +231,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_EQ_Q_v6p] = {"==", "eq.q", ev_quat, ev_quat, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_EQ_S_v6p] = {"==", "eq.s", ev_string, ev_string, ev_integer, @@ -248,7 +248,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { [OP_NE_D_v6p] = {"!=", "ne.d", ev_double, ev_double, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_NE_F_v6p] = {"!=", "ne.f", ev_float, ev_float, ev_integer, @@ -260,7 +260,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_NE_Q_v6p] = {"!=", "ne.q", ev_quat, ev_quat, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_NE_S_v6p] = {"!=", "ne.s", ev_string, ev_string, ev_integer, @@ -277,7 +277,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { [OP_LE_D_v6p] = {"<=", "le.d", ev_double, ev_double, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_LE_F_v6p] = {"<=", "le.f", ev_float, ev_float, ev_integer, @@ -285,7 +285,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_GE_D_v6p] = {">=", "ge.d", ev_double, ev_double, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_GE_F_v6p] = {">=", "ge.f", ev_float, ev_float, ev_integer, @@ -293,15 +293,15 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_LE_S_v6p] = {"<=", "le.s", ev_string, ev_string, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_GE_S_v6p] = {">=", "ge.s", ev_string, ev_string, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_LT_D_v6p] = {"<", "lt.d", ev_double, ev_double, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_LT_F_v6p] = {"<", "lt.f", ev_float, ev_float, ev_integer, @@ -309,7 +309,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_GT_D_v6p] = {">", "gt.d", ev_double, ev_double, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_GT_F_v6p] = {">", "gt.f", ev_float, ev_float, ev_integer, @@ -317,11 +317,11 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_LT_S_v6p] = {"<", "lt.s", ev_string, ev_string, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_GT_S_v6p] = {">", "gt.s", ev_string, ev_string, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_LOAD_F_v6p] = {".", "load.f", @@ -331,7 +331,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_LOAD_D_v6p] = {".", "load.d", ev_entity, ev_field, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga.%Gb(%Ec), %gc", }, [OP_LOAD_V_v6p] = {".", "load.v", @@ -341,7 +341,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_LOAD_Q_v6p] = {".", "load.q", ev_entity, ev_field, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga.%Gb(%Ec), %gc", }, [OP_LOAD_S_v6p] = {".", "load.s", @@ -366,114 +366,114 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_LOAD_I_v6p] = {".", "load.i", ev_entity, ev_field, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga.%Gb(%Ec), %gc", }, [OP_LOAD_P_v6p] = {".", "load.p", ev_entity, ev_field, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga.%Gb(%Ec), %gc", }, [OP_LOADB_D_v6p] = {".", "loadb.d", ev_pointer, ev_integer, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_F_v6p] = {".", "loadb.f", ev_pointer, ev_integer, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_V_v6p] = {".", "loadb.v", ev_pointer, ev_integer, ev_vector, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_Q_v6p] = {".", "loadb.q", ev_pointer, ev_integer, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_S_v6p] = {".", "loadb.s", ev_pointer, ev_integer, ev_string, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_ENT_v6p] = {".", "loadb.ent", ev_pointer, ev_integer, ev_entity, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_FLD_v6p] = {".", "loadb.fld", ev_pointer, ev_integer, ev_field, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_FN_v6p] = {".", "loadb.fn", ev_pointer, ev_integer, ev_func, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_I_v6p] = {".", "loadb.i", ev_pointer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_P_v6p] = {".", "loadb.p", ev_pointer, ev_integer, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADBI_D_v6p] = {".", "loadbi.d", ev_pointer, ev_short, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_F_v6p] = {".", "loadbi.f", ev_pointer, ev_short, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_V_v6p] = {".", "loadbi.v", ev_pointer, ev_short, ev_vector, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_Q_v6p] = {".", "loadbi.q", ev_pointer, ev_short, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_S_v6p] = {".", "loadbi.s", ev_pointer, ev_short, ev_string, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_ENT_v6p] = {".", "loadbi.ent", ev_pointer, ev_short, ev_entity, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_FLD_v6p] = {".", "loadbi.fld", ev_pointer, ev_short, ev_field, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_FN_v6p] = {".", "loadbi.fn", ev_pointer, ev_short, ev_func, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_I_v6p] = {".", "loadbi.i", ev_pointer, ev_short, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_P_v6p] = {".", "loadbi.p", ev_pointer, ev_short, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, @@ -485,105 +485,105 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { [OP_ADDRESS_VOID_v6p] = {"&", "address", ev_void, ev_invalid, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_D_v6p] = {"&", "address.d", ev_double, ev_invalid, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_F_v6p] = {"&", "address.f", ev_float, ev_invalid, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_V_v6p] = {"&", "address.v", ev_vector, ev_invalid, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_Q_v6p] = {"&", "address.q", ev_quat, ev_invalid, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_S_v6p] = {"&", "address.s", ev_string, ev_invalid, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_ENT_v6p] = {"&", "address.ent", ev_entity, ev_invalid, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_FLD_v6p] = {"&", "address.fld", ev_field, ev_invalid, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_FN_v6p] = {"&", "address.fn", ev_func, ev_invalid, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_I_v6p] = {"&", "address.i", ev_integer, ev_invalid, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_P_v6p] = {"&", "address.p", ev_pointer, ev_invalid, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_LEA_v6p] = {"&", "lea", ev_pointer, ev_integer, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "(%Ga + %Gb), %gc", }, [OP_LEAI_v6p] = {"&", "leai", ev_pointer, ev_short, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "(%Ga + %sb), %gc", }, [OP_CONV_IF_v6p] = {"", "conv.if", ev_integer, ev_invalid, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_CONV_FI_v6p] = {"", "conv.fi", ev_float, ev_invalid, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_CONV_ID_v6p] = {"", "conv.id", ev_integer, ev_invalid, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_CONV_DI_v6p] = {"", "conv.di", ev_double, ev_invalid, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_CONV_FD_v6p] = {"", "conv.fd", ev_float, ev_invalid, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_CONV_DF_v6p] = {"", "conv.df", ev_double, ev_invalid, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_STORE_D_v6p] = {"=", "store.d", ev_double, ev_double, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gb", }, [OP_STORE_F_v6p] = {"=", "store.f", @@ -598,7 +598,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_STORE_Q_v6p] = {"=", "store.q", ev_quat, ev_quat, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gb", }, [OP_STORE_S_v6p] = {"=", "store.s", @@ -623,12 +623,12 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_STORE_I_v6p] = {"=", "store.i", ev_integer, ev_integer, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gb", }, [OP_STORE_P_v6p] = {"=", "store.p", ev_pointer, ev_pointer, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gb", }, @@ -649,7 +649,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_STOREP_Q_v6p] = {".=", "storep.q", ev_quat, ev_pointer, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *%Gb", }, [OP_STOREP_S_v6p] = {".=", "storep.s", @@ -674,114 +674,114 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_STOREP_I_v6p] = {".=", "storep.i", ev_integer, ev_pointer, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *%Gb", }, [OP_STOREP_P_v6p] = {".=", "storep.p", ev_pointer, ev_pointer, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *%Gb", }, [OP_STOREB_D_v6p] = {".=", "storeb.d", ev_double, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_F_v6p] = {".=", "storeb.f", ev_float, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_V_v6p] = {".=", "storeb.v", ev_vector, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_Q_v6p] = {".=", "storeb.q", ev_quat, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_S_v6p] = {".=", "storeb.s", ev_string, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_ENT_v6p] = {".=", "storeb.ent", ev_entity, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_FLD_v6p] = {".=", "storeb.fld", ev_field, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_FN_v6p] = {".=", "storeb.fn", ev_func, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_I_v6p] = {".=", "storeb.i", ev_integer, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_P_v6p] = {".=", "storeb.p", ev_pointer, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREBI_D_v6p] = {".=", "storebi.d", ev_double, ev_pointer, ev_short, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_F_v6p] = {".=", "storebi.f", ev_float, ev_pointer, ev_short, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_V_v6p] = {".=", "storebi.v", ev_vector, ev_pointer, ev_short, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_Q_v6p] = {".=", "storebi.q", ev_quat, ev_pointer, ev_short, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_S_v6p] = {".=", "storebi.s", ev_string, ev_pointer, ev_short, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_ENT_v6p] = {".=", "storebi.ent", ev_entity, ev_pointer, ev_short, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_FLD_v6p] = {".=", "storebi.fld", ev_field, ev_pointer, ev_short, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_FN_v6p] = {".=", "storebi.fn", ev_func, ev_pointer, ev_short, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_I_v6p] = {".=", "storebi.i", ev_integer, ev_pointer, ev_short, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_P_v6p] = {".=", "storebi.p", ev_pointer, ev_pointer, ev_short, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, @@ -793,13 +793,13 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { [OP_RETURN_V_v6p] = {"", "return", ev_invalid, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "", }, [OP_NOT_D_v6p] = {"!", "not.d", ev_double, ev_invalid, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_NOT_F_v6p] = {"!", "not.f", @@ -814,7 +814,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_NOT_Q_v6p] = {"!", "not.q", ev_quat, ev_invalid, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_NOT_S_v6p] = {"!", "not.s", @@ -834,7 +834,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_NOT_P_v6p] = {"!", "not.p", ev_pointer, ev_invalid, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, @@ -850,22 +850,22 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_IFBE_v6p] = {"", "ifbe", ev_integer, ev_short, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, [OP_IFB_v6p] = {"", "ifb", ev_integer, ev_short, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, [OP_IFAE_v6p] = {"", "ifae", ev_integer, ev_short, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, [OP_IFA_v6p] = {"", "ifa", ev_integer, ev_short, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, @@ -922,42 +922,42 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_RCALL1_v6p] = {"", "rcall1", ev_func, ev_void, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Fa (%P0b)", }, [OP_RCALL2_v6p] = {"", "rcall2", ev_func, ev_void, ev_void, - PROG_VERSION, + PROG_V6P_VERSION, "%Fa (%P0b, %P1c)", }, [OP_RCALL3_v6p] = {"", "rcall3", ev_func, ev_void, ev_void, - PROG_VERSION, + PROG_V6P_VERSION, "%Fa (%P0b, %P1c, %P2x)", }, [OP_RCALL4_v6p] = {"", "rcall4", ev_func, ev_void, ev_void, - PROG_VERSION, + PROG_V6P_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x)", }, [OP_RCALL5_v6p] = {"", "rcall5", ev_func, ev_void, ev_void, - PROG_VERSION, + PROG_V6P_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x)", }, [OP_RCALL6_v6p] = {"", "rcall6", ev_func, ev_void, ev_void, - PROG_VERSION, + PROG_V6P_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x)", }, [OP_RCALL7_v6p] = {"", "rcall7", ev_func, ev_void, ev_void, - PROG_VERSION, + PROG_V6P_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x)", }, [OP_RCALL8_v6p] = {"", "rcall8", ev_func, ev_void, ev_void, - PROG_VERSION, + PROG_V6P_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x, %P7x)", }, @@ -969,7 +969,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { [OP_STATE_F_v6p] = {"", "state.f", ev_float, ev_func, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %Gb, %Gc", }, @@ -980,12 +980,12 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_JUMP_v6p] = {"", "jump", ev_integer, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga", }, [OP_JUMPB_v6p] = {"", "jumpb", ev_void, ev_integer, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga[%Gb]", }, @@ -1000,23 +1000,23 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { [OP_SHL_F_v6p] = {"<<", "shl.f", ev_float, ev_float, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_SHR_F_v6p] = {">>", "shr.f", ev_float, ev_float, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_SHL_I_v6p] = {"<<", "shl.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_SHR_I_v6p] = {">>", "shr.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_SHR_U_v6p] = {">>", "shr.u", ev_uinteger, ev_integer, ev_uinteger, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_BITAND_v6p] = {"&", "bitand", @@ -1030,481 +1030,481 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { [OP_ADD_I_v6p] = {"+", "add.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_SUB_I_v6p] = {"-", "sub.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_MUL_I_v6p] = {"*", "mul.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_DIV_I_v6p] = {"/", "div.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_REM_I_v6p] = {"%", "rem.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_MOD_I_v6p] = {"%%", "mod.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_BITAND_I_v6p] = {"&", "bitand.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_BITOR_I_v6p] = {"|", "bitor.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_REM_F_v6p] = {"%", "rem.f", ev_float, ev_float, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_MOD_F_v6p] = {"%%", "mod.f", ev_float, ev_float, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_GE_I_v6p] = {">=", "ge.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_LE_I_v6p] = {"<=", "le.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_GT_I_v6p] = {">", "gt.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_LT_I_v6p] = {"<", "lt.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_AND_I_v6p] = {"&&", "and.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_OR_I_v6p] = {"||", "or.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_NOT_I_v6p] = {"!", "not.i", ev_integer, ev_invalid, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_EQ_I_v6p] = {"==", "eq.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_NE_I_v6p] = {"!=", "ne.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_GE_U_v6p] = {">=", "ge.u", ev_uinteger, ev_uinteger, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_LE_U_v6p] = {"<=", "le.u", ev_uinteger, ev_uinteger, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_GT_U_v6p] = {">", "gt.u", ev_uinteger, ev_uinteger, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_LT_U_v6p] = {"<", "lt.u", ev_uinteger, ev_uinteger, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_BITXOR_F_v6p] = {"^", "bitxor.f", ev_float, ev_float, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_BITNOT_F_v6p] = {"~", "bitnot.f", ev_float, ev_invalid, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_BITXOR_I_v6p] = {"^", "bitxor.i", ev_integer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_BITNOT_I_v6p] = {"~", "bitnot.i", ev_integer, ev_invalid, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %gc", }, [OP_GE_P_v6p] = {">=", "ge.p", ev_pointer, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_LE_P_v6p] = {"<=", "le.p", ev_pointer, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_GT_P_v6p] = {">", "gt.p", ev_pointer, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_LT_P_v6p] = {"<", "lt.p", ev_pointer, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_EQ_P_v6p] = {"==", "eq.p", ev_pointer, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_NE_P_v6p] = {"!=", "ne.p", ev_pointer, ev_pointer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, }, [OP_MOVEI_v6p] = {"", "movei", ev_void, ev_short, ev_void, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %sb, %gc", }, [OP_MOVEP_v6p] = {"", "movep", ev_pointer, ev_integer, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %Gb, %Gc", }, [OP_MOVEPI_v6p] = {"", "movepi", ev_pointer, ev_short, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %sb, %Gc", }, [OP_MEMSETI_v6p] = {"", "memseti", ev_integer, ev_short, ev_void, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %sb, %gc", }, [OP_MEMSETP_v6p] = {"", "memsetp", ev_integer, ev_integer, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %Gb, %Gc", }, [OP_MEMSETPI_v6p] = {"", "memsetpi", ev_integer, ev_short, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga, %sb, %Gc", }, [OP_PUSH_S_v6p] = {"", "push.s", ev_string, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga", }, [OP_PUSH_F_v6p] = {"", "push.f", ev_float, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga", }, [OP_PUSH_V_v6p] = {"", "push.v", ev_vector, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga", }, [OP_PUSH_ENT_v6p] = {"", "push.ent", ev_entity, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga", }, [OP_PUSH_FLD_v6p] = {"", "push.fld", ev_field, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga", }, [OP_PUSH_FN_v6p] = {"", "push.fn", ev_func, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga", }, [OP_PUSH_P_v6p] = {"", "push.p", ev_pointer, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga", }, [OP_PUSH_Q_v6p] = {"", "push.q", ev_quat, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga", }, [OP_PUSH_I_v6p] = {"", "push.i", ev_integer, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga", }, [OP_PUSH_D_v6p] = {"", "push.d", ev_double, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%Ga", }, [OP_PUSHB_S_v6p] = {"", "pushb.s", ev_pointer, ev_integer, ev_string, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_F_v6p] = {"", "pushb.f", ev_pointer, ev_integer, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_V_v6p] = {"", "pushb.v", ev_pointer, ev_integer, ev_vector, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_ENT_v6p] = {"", "pushb.ent", ev_pointer, ev_integer, ev_entity, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_FLD_v6p] = {"", "pushb.fld", ev_pointer, ev_integer, ev_field, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_FN_v6p] = {"", "pushb.fn", ev_pointer, ev_integer, ev_func, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_P_v6p] = {"", "pushb.p", ev_pointer, ev_integer, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_Q_v6p] = {"", "pushb.q", ev_pointer, ev_integer, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_I_v6p] = {"", "pushb.i", ev_pointer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_D_v6p] = {"", "pushb.d", ev_pointer, ev_integer, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHBI_S_v6p] = {"", "pushbi.s", ev_pointer, ev_short, ev_string, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_F_v6p] = {"", "pushbi.f", ev_pointer, ev_short, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_V_v6p] = {"", "pushbi.v", ev_pointer, ev_short, ev_vector, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_ENT_v6p] = {"", "pushbi.ent", ev_pointer, ev_short, ev_entity, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_FLD_v6p] = {"", "pushbi.fld", ev_pointer, ev_short, ev_field, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_FN_v6p] = {"", "pushbi.fn", ev_pointer, ev_short, ev_func, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_P_v6p] = {"", "pushbi.p", ev_pointer, ev_short, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_Q_v6p] = {"", "pushbi.q", ev_pointer, ev_short, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_I_v6p] = {"", "pushbi.i", ev_pointer, ev_short, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_D_v6p] = {"", "pushbi.d", ev_pointer, ev_short, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POP_S_v6p] = {"", "pop.s", ev_string, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%ga", }, [OP_POP_F_v6p] = {"", "pop.f", ev_float, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%ga", }, [OP_POP_V_v6p] = {"", "pop.v", ev_vector, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%ga", }, [OP_POP_ENT_v6p] = {"", "pop.ent", ev_entity, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%ga", }, [OP_POP_FLD_v6p] = {"", "pop.fld", ev_field, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%ga", }, [OP_POP_FN_v6p] = {"", "pop.fn", ev_func, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%ga", }, [OP_POP_P_v6p] = {"", "pop.p", ev_pointer, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%ga", }, [OP_POP_Q_v6p] = {"", "pop.q", ev_quat, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%ga", }, [OP_POP_I_v6p] = {"", "pop.i", ev_integer, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%ga", }, [OP_POP_D_v6p] = {"", "pop.d", ev_double, ev_invalid, ev_invalid, - PROG_VERSION, + PROG_V6P_VERSION, "%ga", }, [OP_POPB_S_v6p] = {"", "popb.s", ev_pointer, ev_integer, ev_string, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_F_v6p] = {"", "popb.f", ev_pointer, ev_integer, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_V_v6p] = {"", "popb.v", ev_pointer, ev_integer, ev_vector, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_ENT_v6p] = {"", "popb.ent", ev_pointer, ev_integer, ev_entity, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_FLD_v6p] = {"", "popb.fld", ev_pointer, ev_integer, ev_field, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_FN_v6p] = {"", "popb.fn", ev_pointer, ev_integer, ev_func, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_P_v6p] = {"", "popb.p", ev_pointer, ev_integer, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_Q_v6p] = {"", "popb.q", ev_pointer, ev_integer, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_I_v6p] = {"", "popb.i", ev_pointer, ev_integer, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_D_v6p] = {"", "popb.d", ev_pointer, ev_integer, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPBI_S_v6p] = {"", "popbi.s", ev_pointer, ev_short, ev_string, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_F_v6p] = {"", "popbi.f", ev_pointer, ev_short, ev_float, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_V_v6p] = {"", "popbi.v", ev_pointer, ev_short, ev_vector, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_ENT_v6p] = {"", "popbi.ent", ev_pointer, ev_short, ev_entity, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_FLD_v6p] = {"", "popbi.fld", ev_pointer, ev_short, ev_field, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_FN_v6p] = {"", "popbi.fn", ev_pointer, ev_short, ev_func, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_P_v6p] = {"", "popbi.p", ev_pointer, ev_short, ev_pointer, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_Q_v6p] = {"", "popbi.q", ev_pointer, ev_short, ev_quat, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_I_v6p] = {"", "popbi.i", ev_pointer, ev_short, ev_integer, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_D_v6p] = {"", "popbi.d", ev_pointer, ev_short, ev_double, - PROG_VERSION, + PROG_V6P_VERSION, "*(%Ga + %sb)", }, diff --git a/libs/gamecode/pr_strings.c b/libs/gamecode/pr_strings.c index ba53acac8..f2e5237a6 100644 --- a/libs/gamecode/pr_strings.c +++ b/libs/gamecode/pr_strings.c @@ -242,13 +242,16 @@ PR_LoadStrings (progs_t *pr) while (str < end) { count++; - if (*str == '@' && pr->progs->version == PROG_VERSION) { + if (*str == '@' && pr->progs->version == PROG_V6P_VERSION) { if (!strcmp (str, "@float_promoted@")) { pr->float_promoted = 1; } } str += strlen (str) + 1; } + if (pr->progs->version == PROG_VERSION) { + pr->float_promoted = 1; + } res->ds_mem.alloc = pr_strings_alloc; res->ds_mem.free = pr_strings_free; diff --git a/tools/qfcc/source/options.c b/tools/qfcc/source/options.c index 09989684c..671d3aa85 100644 --- a/tools/qfcc/source/options.c +++ b/tools/qfcc/source/options.c @@ -398,7 +398,7 @@ DecodeArgs (int argc, char **argv) case OPT_ADVANCED: options.traditional = 0; options.advanced = true; - options.code.progsversion = PROG_VERSION; + options.code.progsversion = PROG_V6P_VERSION; options.code.const_initializers = false; break; case OPT_BLOCK_DOT: @@ -505,7 +505,7 @@ DecodeArgs (int argc, char **argv) if (flag) options.code.progsversion = PROG_ID_VERSION; else - options.code.progsversion = PROG_VERSION; + options.code.progsversion = PROG_V6P_VERSION; } else if (!(strcasecmp (temp, "const-initializers"))) { options.code.const_initializers = flag; } @@ -699,7 +699,7 @@ DecodeArgs (int argc, char **argv) options.code.vector_components = true; } if (!options.code.progsversion) - options.code.progsversion = PROG_VERSION; + options.code.progsversion = PROG_V6P_VERSION; if (!options.traditional) { options.advanced = true; add_cpp_def ("-D__RUAMOKO__=1"); diff --git a/tools/qfcc/source/pragma.c b/tools/qfcc/source/pragma.c index d82f2aef4..edabcaaf4 100644 --- a/tools/qfcc/source/pragma.c +++ b/tools/qfcc/source/pragma.c @@ -65,7 +65,7 @@ set_traditional (int traditional) case 0: options.traditional = 0; options.advanced = true; - options.code.progsversion = PROG_VERSION; + options.code.progsversion = PROG_V6P_VERSION; type_default = &type_integer; break; case 1: From 920c5fd99b2226f2c7bf7126ffc0386e90447cc9 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 14:39:32 +0900 Subject: [PATCH 018/360] [gamecode] Add debug event name strings Makes it easier to print nice debug event messages. --- include/QF/pr_debug.h | 2 ++ libs/gamecode/pr_exec.c | 12 ++++++++++++ 2 files changed, 14 insertions(+) diff --git a/include/QF/pr_debug.h b/include/QF/pr_debug.h index 4015f6f65..94c164fe5 100644 --- a/include/QF/pr_debug.h +++ b/include/QF/pr_debug.h @@ -75,6 +75,8 @@ typedef struct pr_debug_header_s { pr_uint_t debug_data; pr_uint_t debug_data_size; } pr_debug_header_t; + +extern const char *prdebug_names[]; #endif typedef enum prdebug_e { diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index ad5808107..8a014b469 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -52,6 +52,18 @@ #include "QF/simd/vec4i.h" #include "compat.h" +const char *prdebug_names[] = { + [prd_none] = "none", + [prd_trace] = "trace", + [prd_breakpoint] = "breakpoint", + [prd_watchpoint] = "watchpoint", + [prd_subenter] = "subenter", + [prd_subexit] = "subexit", + [prd_begin] = "begin", + [prd_terminate] = "terminate", + [prd_runerror] = "runerror", + [prd_error] = "error", +}; /* PR_RunError From bf604b99b39aaa281a696184f8241cd524b1bed6 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 14:41:29 +0900 Subject: [PATCH 019/360] [gamecode] Add automated tests for store ops They even found a bug in the addressing mode functions :) (I'd forgotten that I wanted signed offsets from the pointer and thus forgot to cast st->b to short in order to get the sign extension) --- libs/gamecode/Makemodule.am | 2 + libs/gamecode/pr_exec.c | 18 ++-- libs/gamecode/test/Makemodule.am | 17 ++++ libs/gamecode/test/main.c | 166 +++++++++++++++++++++++++++++++ libs/gamecode/test/test-store.c | 132 ++++++++++++++++++++++++ 5 files changed, 326 insertions(+), 9 deletions(-) create mode 100644 libs/gamecode/test/Makemodule.am create mode 100644 libs/gamecode/test/main.c create mode 100644 libs/gamecode/test/test-store.c diff --git a/libs/gamecode/Makemodule.am b/libs/gamecode/Makemodule.am index dfae7c388..b962f60ad 100644 --- a/libs/gamecode/Makemodule.am +++ b/libs/gamecode/Makemodule.am @@ -1,3 +1,5 @@ +include libs/gamecode/test/Makemodule.am + gc_deps=libs/util/libQFutil.la noinst_LTLIBRARIES += libs/gamecode/libQFgamecode.la diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 8a014b469..e8c186505 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1753,11 +1753,11 @@ pr_entity_mode (progs_t *pr, const dstatement_t *st, int shift) mm_offs = OPA(uint); break; case 2: - // constant indexed pointer: *a + b - mm_offs = OPA(uint) + st->b; + // constant indexed pointer: *a + b (supports -ve offset) + mm_offs = OPA(uint) + (short) st->b; break; case 3: - // verible indexed pointer: *a + *b (supports -ve offset) + // variable indexed pointer: *a + *b (supports -ve offset) mm_offs = OPA(uint) + OPB(int); break; } @@ -1782,11 +1782,11 @@ pr_address_mode (progs_t *pr, const dstatement_t *st, int shift) mm_offs = OPA(uint); break; case 2: - // constant indexed pointer: *a + b - mm_offs = OPA(uint) + st->b; + // constant indexed pointer: *a + b (supports -ve offset) + mm_offs = OPA(uint) + (short) st->b; break; case 3: - // verible indexed pointer: *a + *b (supports -ve offset) + // variable indexed pointer: *a + *b (supports -ve offset) mm_offs = OPA(uint) + OPB(int); break; } @@ -1811,11 +1811,11 @@ pr_jump_mode (progs_t *pr, const dstatement_t *st) jump_offs = OPA(uint); break; case 2: - // constant indexed pointer: *a + b - jump_offs = OPA(uint) + st->b; + // constant indexed pointer: *a + b (supports -ve offset) + jump_offs = OPA(uint) + (short) st->b; break; case 3: - // verible indexed pointer: *a + *b (supports -ve offset) + // variable indexed pointer: *a + *b (supports -ve offset) jump_offs = OPA(uint) + OPB(int); break; } diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am new file mode 100644 index 000000000..9a0bac68a --- /dev/null +++ b/libs/gamecode/test/Makemodule.am @@ -0,0 +1,17 @@ +libs_gamecode_tests = \ + libs/gamecode/test/test-store + +TESTS += $(libs_gamecode_tests) + +check_PROGRAMS += $(libs_gamecode_tests) + +EXTRA_DIST += main.c + +test_gamecode_libs= \ + libs/gamecode/libQFgamecode.la \ + libs/util/libQFutil.la + +libs_gamecode_test_test_store_SOURCES= \ + libs/gamecode/test/test-store.c +libs_gamecode_test_test_store_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_store_DEPENDENCIES= $(test_gamecode_libs) diff --git a/libs/gamecode/test/main.c b/libs/gamecode/test/main.c new file mode 100644 index 000000000..e861d6e46 --- /dev/null +++ b/libs/gamecode/test/main.c @@ -0,0 +1,166 @@ +#include +#include +#include +#include + +#include "QF/va.h" + +#define num_tests (sizeof (tests) / sizeof (tests[0])) +static int test_enabled[num_tests] = { 0 }; + +#include "getopt.h" + +#include "QF/cmd.h" +#include "QF/cvar.h" + +static bfunction_t test_functions[] = { + {}, // null function + { .first_statement = 0 } +}; +static dprograms_t test_progs = { + .version = PROG_VERSION, +}; +static progs_t test_pr; + +static jmp_buf jump_buffer; + +static void +test_debug_handler (prdebug_t event, void *param, void *data) +{ + switch (event) { + case prd_breakpoint: + if (verbose > 0) { + printf ("debug: %s\n", prdebug_names[event]); + } + longjmp (jump_buffer, 1); + case prd_subenter: + if (verbose > 0) { + printf ("debug: subenter %d\n", *(func_t *) param); + } + case prd_subexit: + break; + case prd_trace: + dstatement_t *st = test_pr.pr_statements + test_pr.pr_xstatement; + if (verbose > 0) { + printf ("debug: trace %05x %04x %04x %04x %04x\n", + test_pr.pr_xstatement, st->op, st->a, st->b, st->c); + } + break; + case prd_runerror: + printf ("debug: %s: %s\n", prdebug_names[event], (char *)param); + longjmp (jump_buffer, 3); + case prd_watchpoint: + case prd_begin: + case prd_terminate: + case prd_error: + case prd_none: + printf ("debug: unexpected:%s %p\n", prdebug_names[event], param); + longjmp (jump_buffer, 2); + } +} + +static void +setup_test (test_t *test) +{ + memset (&test_pr, 0, sizeof (test_pr)); + test_pr.progs = &test_progs; + test_pr.debug_handler = test_debug_handler; + test_pr.pr_trace = 1; + test_pr.pr_trace_depth = -1; + test_pr.function_table = test_functions; + test_pr.globals_size = test->num_globals; + pr_uint_t num_globals = test->num_globals + test->extra_globals; + test_pr.pr_globals = malloc (num_globals * sizeof (pr_type_t)); + memcpy (test_pr.pr_globals, test->init_globals, + test->num_globals * sizeof (pr_type_t)); + memset (test_pr.pr_globals + test->num_globals, 0, + test->extra_globals * sizeof (pr_type_t)); + test_pr.pr_statements + = malloc ((test->num_statements + 1) * sizeof (dstatement_t)); + memcpy (test_pr.pr_statements, test->statements, + (test->num_statements + 1) * sizeof (dstatement_t)); + test_pr.pr_statements[test->num_statements] = + (dstatement_t) { OP_BREAK, 0, 0, 0 }; +} + +static int +run_test (test_t *test) +{ + int jump_ret; + int ret = 0; + + setup_test (test); + + if (!(jump_ret = setjmp (jump_buffer))) { + PR_ExecuteProgram (&test_pr, 1); + printf ("returned from progs\n"); + } + if (jump_ret == 1) { + if (memcmp (test_pr.pr_globals, test->expect_globals, + test->num_globals * sizeof (pr_int_t)) == 0) { + ret = 1; + printf ("test #%zd: %s: OK\n", test - tests, test->desc); + } else { + printf ("test #%zd: %s: bytes differ\n", test - tests, test->desc); + } + } else { + printf ("test #%zd: %s: critical failure\n", test - tests, test->desc); + } + free (test_pr.pr_globals); + free (test_pr.pr_statements); + return ret; +} + +int +main (int argc, char **argv) +{ + int c; + size_t i, test; + int pass = 1; + + Cmd_Init_Hash (); + Cvar_Init_Hash (); + Cmd_Init (); + Cvar_Init (); + PR_Init_Cvars (); + + while ((c = getopt (argc, argv, "qvt:")) != EOF) { + switch (c) { + case 'q': + verbose--; + break; + case 'v': + verbose++; + break; + case 't': + test = atoi (optarg); + if (test < num_tests) { + test_enabled[test] = 1; + } else { + fprintf (stderr, "Bad test number (0 - %zd)\n", num_tests); + return 1; + } + break; + default: + fprintf (stderr, "-q (quiet) -v (verbose) and/or -t TEST " + "(test number)\n"); + return 1; + } + } + + for (i = 0; i < num_tests; i++) + if (test_enabled[i]) + break; + if (i == num_tests) { + for (i = 0; i < num_tests; i++) + test_enabled[i] = 1; + } + + for (i = 0; i < num_tests; i++) { + if (!test_enabled[i]) + continue; + pass &= run_test (&tests[i]); + } + + return !pass; +} diff --git a/libs/gamecode/test/test-store.c b/libs/gamecode/test/test-store.c new file mode 100644 index 000000000..aacddc4e8 --- /dev/null +++ b/libs/gamecode/test/test-store.c @@ -0,0 +1,132 @@ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "QF/progs.h" + +static int verbose = 0; + +// both calculates the number of globals in the test, and ensures that both +// init and expect are the same size (will product a "void value not ignored" +// error if the sizes differ) +#define num_globals(init, expect) \ + __builtin_choose_expr ( \ + sizeof (init) == sizeof (expect), sizeof (init) / sizeof (init[0]), \ + (void) 0\ + ) + +// calculate the numver of statements in the test +#define num_statements(statements) \ + (sizeof (statements) / sizeof (statements[0])) + +typedef struct { + const char *desc; + pr_uint_t extra_globals; + pr_uint_t num_globals; + pr_uint_t num_statements; + dstatement_t *statements; + pr_int_t *init_globals; + pr_int_t *expect_globals; +} test_t; + +static pr_int_t test_globals_init[] = { + // pointers + 24, 26, 28, 29, + 32, -4, -2, 0, + 1, 4, 0xdeadbeef, 0xfeedf00d, + // source data + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + // destination data + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, +}; + +static pr_int_t test_globals_expect[] = { + // pointers + 24, 26, 28, 29, + 32, -4, -2, 0, + 1, 4, 0xdeadbeef, 0xfeedf00d, + // source data + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + // destination data + 11, 12, 9, 10, + 8, 5, 6, 7, + 1, 2, 3, 4, +}; + +#define BASE(b, base) (((base) & 3) << OP_##b##_SHIFT) +#define OP(a, b, c, op) ((op) | BASE(A, a) | BASE(B, b) | BASE(C, c)) + +static dstatement_t store_A_statements[] = { + {OP(0, 0, 0, OP_STORE_A_4), 32, 0, 12}, + {OP(0, 0, 0, OP_STORE_A_3), 29, 0, 16}, + {OP(0, 0, 0, OP_STORE_A_1), 28, 0, 19}, + {OP(0, 0, 0, OP_STORE_A_2), 26, 0, 20}, + {OP(0, 0, 0, OP_STORE_A_2), 24, 0, 22}, +}; + +static dstatement_t store_B_statements[] = { + {OP(0, 0, 0, OP_STORE_B_4), 4, 0, 12}, + {OP(0, 0, 0, OP_STORE_B_3), 3, 0, 16}, + {OP(0, 0, 0, OP_STORE_B_1), 2, 0, 19}, + {OP(0, 0, 0, OP_STORE_B_2), 1, 0, 20}, + {OP(0, 0, 0, OP_STORE_B_2), 0, 0, 22}, +}; + +static dstatement_t store_C_statements[] = { + {OP(0, 0, 0, OP_STORE_C_4), 2, 4, 12}, + {OP(0, 0, 0, OP_STORE_C_3), 2, 1, 16}, + {OP(0, 0, 0, OP_STORE_C_1), 2, 0, 19}, + {OP(0, 0, 0, OP_STORE_C_2), 2, -2, 20}, + {OP(0, 0, 0, OP_STORE_C_2), 2, -4, 22}, +}; + +static dstatement_t store_D_statements[] = { + {OP(0, 0, 0, OP_STORE_D_4), 2, 9, 12}, + {OP(0, 0, 0, OP_STORE_D_3), 2, 8, 16}, + {OP(0, 0, 0, OP_STORE_D_1), 2, 7, 19}, + {OP(0, 0, 0, OP_STORE_D_2), 2, 6, 20}, + {OP(0, 0, 0, OP_STORE_D_2), 2, 5, 22}, +}; + +test_t tests[] = { + { + .desc = "store A", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (store_A_statements), + .statements = store_A_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "store B", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (store_B_statements), + .statements = store_B_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "store C", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (store_C_statements), + .statements = store_C_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "store D", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (store_D_statements), + .statements = store_D_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, +}; + +#include "main.c" From 28df32eb0d77ddae0810b62f0c3e4ee3495f75c9 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 14:45:12 +0900 Subject: [PATCH 020/360] [gamecode] Use pr_memset instead of memset This keeps things inline and matches the quakec exec loop. Also removes the need to calculate the size. --- libs/gamecode/pr_exec.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index e8c186505..1543d9c59 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -2606,15 +2606,13 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OP_op_T (GE, U, ulong, ulvec2, ulvec4, >=); //FIXME float shift case OP_MEMSET_I: - memset (op_c, OPA(int), st->b * sizeof (pr_type_t)); + pr_memset (op_c, OPA(int), st->b); break; case OP_MEMSET_P: - memset (pr->pr_globals + OPC(int), OPA(int), - OPB(uint) * sizeof (pr_type_t)); + pr_memset (pr->pr_globals + OPC(int), OPA(int), OPB(uint)); break; case OP_MEMSET_PI: - memset (pr->pr_globals + OPC(int), OPA(int), - st->b * sizeof (pr_type_t)); + pr_memset (pr->pr_globals + OPC(int), OPA(int), st->b); break; // 1 1110 OP_op_T (LE, u, uint, uivec2, uivec4, <=); From c86f1f671b400f6acaa32185354b176d5c85dcd6 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 15:22:34 +0900 Subject: [PATCH 021/360] [gamecode] Add tests for load instructions This needed the test struct declaration to be moved out to a head file so it can be shared with other tests. --- libs/gamecode/test/Makemodule.am | 8 ++- libs/gamecode/test/head.c | 31 +++++++++ libs/gamecode/test/main.c | 7 +- libs/gamecode/test/test-load.c | 106 +++++++++++++++++++++++++++++++ libs/gamecode/test/test-store.c | 31 +-------- 5 files changed, 151 insertions(+), 32 deletions(-) create mode 100644 libs/gamecode/test/head.c create mode 100644 libs/gamecode/test/test-load.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index 9a0bac68a..e8a21ee58 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -1,16 +1,22 @@ libs_gamecode_tests = \ + libs/gamecode/test/test-load \ libs/gamecode/test/test-store TESTS += $(libs_gamecode_tests) check_PROGRAMS += $(libs_gamecode_tests) -EXTRA_DIST += main.c +EXTRA_DIST += head.c main.c test_gamecode_libs= \ libs/gamecode/libQFgamecode.la \ libs/util/libQFutil.la +libs_gamecode_test_test_load_SOURCES= \ + libs/gamecode/test/test-load.c +libs_gamecode_test_test_load_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_load_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_store_SOURCES= \ libs/gamecode/test/test-store.c libs_gamecode_test_test_store_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/head.c b/libs/gamecode/test/head.c new file mode 100644 index 000000000..c4e099c78 --- /dev/null +++ b/libs/gamecode/test/head.c @@ -0,0 +1,31 @@ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "QF/progs.h" + +static int verbose = 0; + +// both calculates the number of globals in the test, and ensures that both +// init and expect are the same size (will product a "void value not ignored" +// error if the sizes differ) +#define num_globals(init, expect) \ + __builtin_choose_expr ( \ + sizeof (init) == sizeof (expect), sizeof (init) / sizeof (init[0]), \ + (void) 0\ + ) + +// calculate the numver of statements in the test +#define num_statements(statements) \ + (sizeof (statements) / sizeof (statements[0])) + +typedef struct { + const char *desc; + pr_uint_t edict_area; + pr_uint_t extra_globals; + pr_uint_t num_globals; + pr_uint_t num_statements; + dstatement_t *statements; + pr_int_t *init_globals; + pr_int_t *expect_globals; +} test_t; diff --git a/libs/gamecode/test/main.c b/libs/gamecode/test/main.c index e861d6e46..184db9cf4 100644 --- a/libs/gamecode/test/main.c +++ b/libs/gamecode/test/main.c @@ -68,6 +68,7 @@ setup_test (test_t *test) test_pr.pr_trace = 1; test_pr.pr_trace_depth = -1; test_pr.function_table = test_functions; + test_pr.globals_size = test->num_globals; pr_uint_t num_globals = test->num_globals + test->extra_globals; test_pr.pr_globals = malloc (num_globals * sizeof (pr_type_t)); @@ -75,6 +76,10 @@ setup_test (test_t *test) test->num_globals * sizeof (pr_type_t)); memset (test_pr.pr_globals + test->num_globals, 0, test->extra_globals * sizeof (pr_type_t)); + if (test->edict_area) { + test_pr.pr_edict_area = test_pr.pr_globals + test->edict_area; + } + test_pr.pr_statements = malloc ((test->num_statements + 1) * sizeof (dstatement_t)); memcpy (test_pr.pr_statements, test->statements, @@ -101,7 +106,7 @@ run_test (test_t *test) ret = 1; printf ("test #%zd: %s: OK\n", test - tests, test->desc); } else { - printf ("test #%zd: %s: bytes differ\n", test - tests, test->desc); + printf ("test #%zd: %s: words differ\n", test - tests, test->desc); } } else { printf ("test #%zd: %s: critical failure\n", test - tests, test->desc); diff --git a/libs/gamecode/test/test-load.c b/libs/gamecode/test/test-load.c new file mode 100644 index 000000000..212aaa49b --- /dev/null +++ b/libs/gamecode/test/test-load.c @@ -0,0 +1,106 @@ +#include "head.c" + +static pr_int_t test_globals_init[] = { + // pointers + 24, 26, 28, 29, + 32, -4, -2, 0, + 1, 4, 0xdeadbeef, 0xfeedf00d, + // destination data + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + // source data + 11, 12, 9, 10, + 8, 5, 6, 7, + 1, 2, 3, 4, +}; + +static pr_int_t test_globals_expect[] = { + // pointers + 24, 26, 28, 29, + 32, -4, -2, 0, + 1, 4, 0xdeadbeef, 0xfeedf00d, + // destination data + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + // source data + 11, 12, 9, 10, + 8, 5, 6, 7, + 1, 2, 3, 4, +}; + +#define BASE(b, base) (((base) & 3) << OP_##b##_SHIFT) +#define OP(a, b, c, op) ((op) | BASE(A, a) | BASE(B, b) | BASE(C, c)) + +static dstatement_t load_E_statements[] = { + {OP(0, 0, 0, OP_LOAD_E_4), 7, 9, 12}, + {OP(0, 0, 0, OP_LOAD_E_3), 7, 8, 16}, + {OP(0, 0, 0, OP_LOAD_E_1), 7, 7, 19}, + {OP(0, 0, 0, OP_LOAD_E_2), 7, 6, 20}, + {OP(0, 0, 0, OP_LOAD_E_2), 7, 5, 22}, +}; + +static dstatement_t load_B_statements[] = { + {OP(0, 0, 0, OP_LOAD_B_4), 4, 0, 12}, + {OP(0, 0, 0, OP_LOAD_B_3), 3, 0, 16}, + {OP(0, 0, 0, OP_LOAD_B_1), 2, 0, 19}, + {OP(0, 0, 0, OP_LOAD_B_2), 1, 0, 20}, + {OP(0, 0, 0, OP_LOAD_B_2), 0, 0, 22}, +}; + +static dstatement_t load_C_statements[] = { + {OP(0, 0, 0, OP_LOAD_C_4), 2, 4, 12}, + {OP(0, 0, 0, OP_LOAD_C_3), 2, 1, 16}, + {OP(0, 0, 0, OP_LOAD_C_1), 2, 0, 19}, + {OP(0, 0, 0, OP_LOAD_C_2), 2, -2, 20}, + {OP(0, 0, 0, OP_LOAD_C_2), 2, -4, 22}, +}; + +static dstatement_t load_D_statements[] = { + {OP(0, 0, 0, OP_LOAD_D_4), 2, 9, 12}, + {OP(0, 0, 0, OP_LOAD_D_3), 2, 8, 16}, + {OP(0, 0, 0, OP_LOAD_D_1), 2, 7, 19}, + {OP(0, 0, 0, OP_LOAD_D_2), 2, 6, 20}, + {OP(0, 0, 0, OP_LOAD_D_2), 2, 5, 22}, +}; + +test_t tests[] = { + { + .desc = "load E", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (load_E_statements), + .statements = load_E_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + // FIXME negative field offsets are not official but work because all + // offset calculations are done in 32-bit and thus wrap anyway + .edict_area = 28, + }, + { + .desc = "load B", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (load_B_statements), + .statements = load_B_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "load C", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (load_C_statements), + .statements = load_C_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "load D", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (load_D_statements), + .statements = load_D_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, +}; + +#include "main.c" diff --git a/libs/gamecode/test/test-store.c b/libs/gamecode/test/test-store.c index aacddc4e8..dee244485 100644 --- a/libs/gamecode/test/test-store.c +++ b/libs/gamecode/test/test-store.c @@ -1,33 +1,4 @@ -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include "QF/progs.h" - -static int verbose = 0; - -// both calculates the number of globals in the test, and ensures that both -// init and expect are the same size (will product a "void value not ignored" -// error if the sizes differ) -#define num_globals(init, expect) \ - __builtin_choose_expr ( \ - sizeof (init) == sizeof (expect), sizeof (init) / sizeof (init[0]), \ - (void) 0\ - ) - -// calculate the numver of statements in the test -#define num_statements(statements) \ - (sizeof (statements) / sizeof (statements[0])) - -typedef struct { - const char *desc; - pr_uint_t extra_globals; - pr_uint_t num_globals; - pr_uint_t num_statements; - dstatement_t *statements; - pr_int_t *init_globals; - pr_int_t *expect_globals; -} test_t; +#include "head.c" static pr_int_t test_globals_init[] = { // pointers From ffbb6122b9f485edaf31cc0d44713b8ead88cc78 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 16:29:42 +0900 Subject: [PATCH 022/360] [gamecode] Add tests for push and pop --- libs/gamecode/test/Makemodule.am | 6 + libs/gamecode/test/head.c | 6 +- libs/gamecode/test/main.c | 28 +++- libs/gamecode/test/test-load.c | 3 - libs/gamecode/test/test-stack.c | 227 +++++++++++++++++++++++++++++++ libs/gamecode/test/test-store.c | 3 - 6 files changed, 262 insertions(+), 11 deletions(-) create mode 100644 libs/gamecode/test/test-stack.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index e8a21ee58..b06e1c9fa 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -1,5 +1,6 @@ libs_gamecode_tests = \ libs/gamecode/test/test-load \ + libs/gamecode/test/test-stack \ libs/gamecode/test/test-store TESTS += $(libs_gamecode_tests) @@ -17,6 +18,11 @@ libs_gamecode_test_test_load_SOURCES= \ libs_gamecode_test_test_load_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_load_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_stack_SOURCES= \ + libs/gamecode/test/test-stack.c +libs_gamecode_test_test_stack_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_stack_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_store_SOURCES= \ libs/gamecode/test/test-store.c libs_gamecode_test_test_store_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/head.c b/libs/gamecode/test/head.c index c4e099c78..c7db8fb26 100644 --- a/libs/gamecode/test/head.c +++ b/libs/gamecode/test/head.c @@ -19,9 +19,13 @@ static int verbose = 0; #define num_statements(statements) \ (sizeof (statements) / sizeof (statements[0])) +#define BASE(b, base) (((base) & 3) << OP_##b##_SHIFT) +#define OP(a, b, c, op) ((op) | BASE(A, a) | BASE(B, b) | BASE(C, c)) + typedef struct { const char *desc; - pr_uint_t edict_area; + pointer_t edict_area; + pointer_t stack_size; pr_uint_t extra_globals; pr_uint_t num_globals; pr_uint_t num_statements; diff --git a/libs/gamecode/test/main.c b/libs/gamecode/test/main.c index 184db9cf4..4e231b5e0 100644 --- a/libs/gamecode/test/main.c +++ b/libs/gamecode/test/main.c @@ -27,6 +27,8 @@ static jmp_buf jump_buffer; static void test_debug_handler (prdebug_t event, void *param, void *data) { + progs_t *pr = data; + switch (event) { case prd_breakpoint: if (verbose > 0) { @@ -42,8 +44,16 @@ test_debug_handler (prdebug_t event, void *param, void *data) case prd_trace: dstatement_t *st = test_pr.pr_statements + test_pr.pr_xstatement; if (verbose > 0) { - printf ("debug: trace %05x %04x %04x %04x %04x\n", - test_pr.pr_xstatement, st->op, st->a, st->b, st->c); + printf ("debug: trace %05x %04x %04x %04x %04x%s\n", + test_pr.pr_xstatement, st->op, st->a, st->b, st->c, + pr->globals.stack ? va (0, " %05x", *pr->globals.stack) + : ""); + } + if (pr->globals.stack) { + if (*pr->globals.stack & 3) { + printf ("stack not aligned: %d\n", *pr->globals.stack); + longjmp (jump_buffer, 3); + } } break; case prd_runerror: @@ -65,17 +75,26 @@ setup_test (test_t *test) memset (&test_pr, 0, sizeof (test_pr)); test_pr.progs = &test_progs; test_pr.debug_handler = test_debug_handler; + test_pr.debug_data = &test_pr; test_pr.pr_trace = 1; test_pr.pr_trace_depth = -1; test_pr.function_table = test_functions; - test_pr.globals_size = test->num_globals; - pr_uint_t num_globals = test->num_globals + test->extra_globals; + pr_uint_t num_globals = test->num_globals; + num_globals += test->extra_globals + test->stack_size; + + test_pr.globals_size = num_globals; test_pr.pr_globals = malloc (num_globals * sizeof (pr_type_t)); memcpy (test_pr.pr_globals, test->init_globals, test->num_globals * sizeof (pr_type_t)); memset (test_pr.pr_globals + test->num_globals, 0, test->extra_globals * sizeof (pr_type_t)); + if (test->stack_size) { + pointer_t stack = num_globals - test->stack_size; + test_pr.stack_bottom = stack + 4; + test_pr.globals.stack = (pointer_t *) (test_pr.pr_globals + stack); + *test_pr.globals.stack = num_globals; + } if (test->edict_area) { test_pr.pr_edict_area = test_pr.pr_globals + test->edict_area; } @@ -128,6 +147,7 @@ main (int argc, char **argv) Cmd_Init (); Cvar_Init (); PR_Init_Cvars (); + pr_boundscheck->int_val = 1; while ((c = getopt (argc, argv, "qvt:")) != EOF) { switch (c) { diff --git a/libs/gamecode/test/test-load.c b/libs/gamecode/test/test-load.c index 212aaa49b..e283ced38 100644 --- a/libs/gamecode/test/test-load.c +++ b/libs/gamecode/test/test-load.c @@ -30,9 +30,6 @@ static pr_int_t test_globals_expect[] = { 1, 2, 3, 4, }; -#define BASE(b, base) (((base) & 3) << OP_##b##_SHIFT) -#define OP(a, b, c, op) ((op) | BASE(A, a) | BASE(B, b) | BASE(C, c)) - static dstatement_t load_E_statements[] = { {OP(0, 0, 0, OP_LOAD_E_4), 7, 9, 12}, {OP(0, 0, 0, OP_LOAD_E_3), 7, 8, 16}, diff --git a/libs/gamecode/test/test-stack.c b/libs/gamecode/test/test-stack.c new file mode 100644 index 000000000..183e33694 --- /dev/null +++ b/libs/gamecode/test/test-stack.c @@ -0,0 +1,227 @@ +#include "head.c" + +static pr_int_t test_globals_init1[] = { + // pointers + 24, 26, 28, 29, + 32, -4, -2, 0, + 1, 4, 0xdeadbeef, 0xfeedf00d, + // source data + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + // destination data + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, +}; + +static pr_int_t test_globals_expect1[] = { + // pointers + 24, 26, 28, 29, + 32, -4, -2, 0, + 1, 4, 0xdeadbeef, 0xfeedf00d, + // source data + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + // destination data + 11, 12, 9, 10, + 8, 5, 6, 7, + 1, 2, 3, 4, +}; + +static pr_int_t test_globals_init2[] = { + // pointers + 24, 26, 28, 29, + 32, -4, -2, 0, + 1, 4, 0xdeadbeef, 0xfeedf00d, + // destination data + 0, 0, 0, 0, + 0, 0, 0, 0, + 0, 0, 0, 0, + // source data + 11, 12, 9, 10, + 8, 5, 6, 7, + 1, 2, 3, 4, +}; + +static pr_int_t test_globals_expect2[] = { + // pointers + 24, 26, 28, 29, + 32, -4, -2, 0, + 1, 4, 0xdeadbeef, 0xfeedf00d, + // destination data + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 11, 12, + // source data + 11, 12, 9, 10, + 8, 5, 6, 7, + 1, 2, 3, 4, +}; + +static dstatement_t stack_AA_statements[] = { + {OP(0, 0, 0, OP_PUSH_A_4), 12, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_3), 16, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_1), 19, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_2), 20, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_2), 22, 0, 0}, + + {OP(0, 0, 0, OP_POP_A_2), 24, 0, 0}, + {OP(0, 0, 0, OP_POP_A_2), 26, 0, 0}, + {OP(0, 0, 0, OP_POP_A_1), 28, 0, 0}, + {OP(0, 0, 0, OP_POP_A_3), 29, 0, 0}, + {OP(0, 0, 0, OP_POP_A_4), 32, 0, 0}, +}; + +static dstatement_t stack_AB_statements[] = { + {OP(0, 0, 0, OP_PUSH_A_4), 12, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_3), 16, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_1), 19, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_2), 20, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_2), 22, 0, 0}, + + {OP(0, 0, 0, OP_POP_B_2), 0, 0, 0}, + {OP(0, 0, 0, OP_POP_B_2), 1, 0, 0}, + {OP(0, 0, 0, OP_POP_B_1), 2, 0, 0}, + {OP(0, 0, 0, OP_POP_B_3), 3, 0, 0}, + {OP(0, 0, 0, OP_POP_B_4), 4, 0, 0}, +}; + +static dstatement_t stack_AC_statements[] = { + {OP(0, 0, 0, OP_PUSH_A_4), 12, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_3), 16, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_1), 19, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_2), 20, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_2), 22, 0, 0}, + + {OP(0, 0, 0, OP_POP_C_2), 2, -4, 0}, + {OP(0, 0, 0, OP_POP_C_2), 2, -2, 0}, + {OP(0, 0, 0, OP_POP_C_1), 2, 0, 0}, + {OP(0, 0, 0, OP_POP_C_3), 2, 1, 0}, + {OP(0, 0, 0, OP_POP_C_4), 2, 4, 0}, +}; + +static dstatement_t stack_AD_statements[] = { + {OP(0, 0, 0, OP_PUSH_A_4), 12, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_3), 16, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_1), 19, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_2), 20, 0, 0}, + {OP(0, 0, 0, OP_PUSH_A_2), 22, 0, 0}, + + {OP(0, 0, 0, OP_POP_D_2), 2, 5, 0}, + {OP(0, 0, 0, OP_POP_D_2), 2, 6, 0}, + {OP(0, 0, 0, OP_POP_D_1), 2, 7, 0}, + {OP(0, 0, 0, OP_POP_D_3), 2, 8, 0}, + {OP(0, 0, 0, OP_POP_D_4), 2, 9, 0}, +}; + +static dstatement_t stack_BA_statements[] = { + {OP(0, 0, 0, OP_PUSH_B_2), 0, 0, 0}, + {OP(0, 0, 0, OP_PUSH_B_2), 1, 0, 0}, + {OP(0, 0, 0, OP_PUSH_B_1), 2, 0, 0}, + {OP(0, 0, 0, OP_PUSH_B_3), 3, 0, 0}, + {OP(0, 0, 0, OP_PUSH_B_4), 4, 0, 0}, + + {OP(0, 0, 0, OP_POP_A_4), 12, 0, 0}, + {OP(0, 0, 0, OP_POP_A_3), 16, 0, 0}, + {OP(0, 0, 0, OP_POP_A_1), 19, 0, 0}, + {OP(0, 0, 0, OP_POP_A_2), 20, 0, 0}, + {OP(0, 0, 0, OP_POP_A_2), 22, 0, 0}, +}; + +static dstatement_t stack_CA_statements[] = { + {OP(0, 0, 0, OP_PUSH_C_2), 2, -4, 0}, + {OP(0, 0, 0, OP_PUSH_C_2), 2, -2, 0}, + {OP(0, 0, 0, OP_PUSH_C_1), 2, 0, 0}, + {OP(0, 0, 0, OP_PUSH_C_3), 2, 1, 0}, + {OP(0, 0, 0, OP_PUSH_C_4), 2, 4, 0}, + + {OP(0, 0, 0, OP_POP_A_4), 12, 0, 0}, + {OP(0, 0, 0, OP_POP_A_3), 16, 0, 0}, + {OP(0, 0, 0, OP_POP_A_1), 19, 0, 0}, + {OP(0, 0, 0, OP_POP_A_2), 20, 0, 0}, + {OP(0, 0, 0, OP_POP_A_2), 22, 0, 0}, +}; + +static dstatement_t stack_DA_statements[] = { + {OP(0, 0, 0, OP_PUSH_D_2), 2, 5, 0}, + {OP(0, 0, 0, OP_PUSH_D_2), 2, 6, 0}, + {OP(0, 0, 0, OP_PUSH_D_1), 2, 7, 0}, + {OP(0, 0, 0, OP_PUSH_D_3), 2, 8, 0}, + {OP(0, 0, 0, OP_PUSH_D_4), 2, 9, 0}, + + {OP(0, 0, 0, OP_POP_A_4), 12, 0, 0}, + {OP(0, 0, 0, OP_POP_A_3), 16, 0, 0}, + {OP(0, 0, 0, OP_POP_A_1), 19, 0, 0}, + {OP(0, 0, 0, OP_POP_A_2), 20, 0, 0}, + {OP(0, 0, 0, OP_POP_A_2), 22, 0, 0}, +}; + +test_t tests[] = { + { + .desc = "stack push A pop A", + .stack_size = 32, + .num_globals = num_globals (test_globals_init1, test_globals_expect1), + .num_statements = num_statements (stack_AA_statements), + .statements = stack_AA_statements, + .init_globals = test_globals_init1, + .expect_globals = test_globals_expect1, + }, + { + .desc = "stack push A pop B", + .stack_size = 32, + .num_globals = num_globals (test_globals_init1, test_globals_expect1), + .num_statements = num_statements (stack_AB_statements), + .statements = stack_AB_statements, + .init_globals = test_globals_init1, + .expect_globals = test_globals_expect1, + }, + { + .desc = "stack push A pop C", + .stack_size = 32, + .num_globals = num_globals (test_globals_init1, test_globals_expect1), + .num_statements = num_statements (stack_AC_statements), + .statements = stack_AC_statements, + .init_globals = test_globals_init1, + .expect_globals = test_globals_expect1, + }, + { + .desc = "stack push A pop D", + .stack_size = 32, + .num_globals = num_globals (test_globals_init1, test_globals_expect1), + .num_statements = num_statements (stack_AD_statements), + .statements = stack_AD_statements, + .init_globals = test_globals_init1, + .expect_globals = test_globals_expect1, + }, + { + .desc = "stack push B pop A", + .stack_size = 32, + .num_globals = num_globals (test_globals_init2, test_globals_expect2), + .num_statements = num_statements (stack_BA_statements), + .statements = stack_BA_statements, + .init_globals = test_globals_init2, + .expect_globals = test_globals_expect2, + }, + { + .desc = "stack push C pop A", + .stack_size = 32, + .num_globals = num_globals (test_globals_init2, test_globals_expect2), + .num_statements = num_statements (stack_CA_statements), + .statements = stack_CA_statements, + .init_globals = test_globals_init2, + .expect_globals = test_globals_expect2, + }, + { + .desc = "stack push D pop A", + .stack_size = 32, + .num_globals = num_globals (test_globals_init2, test_globals_expect2), + .num_statements = num_statements (stack_DA_statements), + .statements = stack_DA_statements, + .init_globals = test_globals_init2, + .expect_globals = test_globals_expect2, + }, +}; + +#include "main.c" diff --git a/libs/gamecode/test/test-store.c b/libs/gamecode/test/test-store.c index dee244485..dc580f028 100644 --- a/libs/gamecode/test/test-store.c +++ b/libs/gamecode/test/test-store.c @@ -30,9 +30,6 @@ static pr_int_t test_globals_expect[] = { 1, 2, 3, 4, }; -#define BASE(b, base) (((base) & 3) << OP_##b##_SHIFT) -#define OP(a, b, c, op) ((op) | BASE(A, a) | BASE(B, b) | BASE(C, c)) - static dstatement_t store_A_statements[] = { {OP(0, 0, 0, OP_STORE_A_4), 32, 0, 12}, {OP(0, 0, 0, OP_STORE_A_3), 29, 0, 16}, From fd298f360159b9066c3eb993948535d2c1a72ae1 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 17:54:54 +0900 Subject: [PATCH 023/360] [gamecode] Create a mask for extracting the opcode Got tired of copying the full thing around. --- include/QF/pr_comp.h | 1 + libs/gamecode/pr_exec.c | 6 +++--- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index df81d606f..541c69978 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -598,6 +598,7 @@ typedef enum { #define OP_A_BASE (3 << OP_A_SHIFT) #define OP_B_BASE (3 << OP_B_SHIFT) #define OP_C_BASE (3 << OP_C_SHIFT) +#define OP_MASK (~(OP_BREAK|OP_A_BASE|OP_B_BASE|OP_C_BASE)) typedef enum { OP_with_zero, diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 1543d9c59..1e41cbe30 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1713,7 +1713,7 @@ op_call: */ default: - PR_RunError (pr, "Bad opcode %i", st->op); + PR_RunError (pr, "Bad opcode %i", st->op & ~OP_BREAK); } if (pr->watch && pr->watch->integer_var != old_val.integer_var) { if (!pr->wp_conditional @@ -1923,7 +1923,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) pr_type_t *stk; pr_type_t *mm; func_t function; - pr_opcode_e st_op = st->op & ~(OP_BREAK|OP_A_BASE|OP_B_BASE|OP_C_BASE); + pr_opcode_e st_op = st->op & OP_MASK; switch (st_op) { // 0 0000 case OP_LOAD_E_1: @@ -2623,7 +2623,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) //FIXME conversion 3 default: - PR_RunError (pr, "Bad opcode %i", st->op); + PR_RunError (pr, "Bad opcode o%03o", st->op & OP_MASK); } if (pr->watch && pr->watch->integer_var != old_val.integer_var) { if (!pr->wp_conditional From 9084121ad28528ab2dff42fb26e7db2b11217409 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 17:55:45 +0900 Subject: [PATCH 024/360] [simd] Correct result for dot2f It turns out gcc optimizes the obvious code nicely. It doesn't do so well for cmul, but I decided to use obvious code anyway (the instruction counts were the same, so maybe it doesn't get better for a single pair of operands). --- include/QF/simd/vec2f.h | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/include/QF/simd/vec2f.h b/include/QF/simd/vec2f.h index ffa403ad4..b75efcd8e 100644 --- a/include/QF/simd/vec2f.h +++ b/include/QF/simd/vec2f.h @@ -120,9 +120,7 @@ vec2f_t dot2f (vec2f_t a, vec2f_t b) { vec2f_t c = a * b; - vec4f_t t = { c[0], c[1], 0, 0 }; - t = _mm_hadd_ps (t, t); - return (vec2f_t) { t[0], t[1] }; + return (vec2f_t) { c[0] + c[1], c[0] + c[1] }; } #ifndef IMPLEMENT_VEC2F_Funcs @@ -135,10 +133,7 @@ cmulf (vec2f_t a, vec2f_t b) { vec2f_t c1 = a * b[0]; vec2f_t c2 = a * b[1]; - vec4f_t c14 ={ c1[0], c1[1], 0, 0 }; - vec4f_t c24 ={ c2[1], c2[0], 0, 0 }; - vec4f_t c = _mm_addsub_ps (c14, c24); - return (vec2f_t) { c[0], c[1] }; + return (vec2f_t) { c1[0] - c2[1], c1[1] + c2[0] }; } #ifndef IMPLEMENT_VEC2F_Funcs From b8d04874c34c0a1a3e6e6ff401f6db61498e3431 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 17:58:16 +0900 Subject: [PATCH 025/360] [gamecode] Add some math tests Hit a show stopper when it came to swizzle (not implemented yet). I guess I know what I need to do next :P. --- libs/gamecode/test/Makemodule.am | 6 +++ libs/gamecode/test/main.c | 23 +++++++--- libs/gamecode/test/test-math.c | 77 ++++++++++++++++++++++++++++++++ 3 files changed, 99 insertions(+), 7 deletions(-) create mode 100644 libs/gamecode/test/test-math.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index b06e1c9fa..433fad58f 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -1,5 +1,6 @@ libs_gamecode_tests = \ libs/gamecode/test/test-load \ + libs/gamecode/test/test-math \ libs/gamecode/test/test-stack \ libs/gamecode/test/test-store @@ -18,6 +19,11 @@ libs_gamecode_test_test_load_SOURCES= \ libs_gamecode_test_test_load_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_load_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_math_SOURCES= \ + libs/gamecode/test/test-math.c +libs_gamecode_test_test_math_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_math_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_stack_SOURCES= \ libs/gamecode/test/test-stack.c libs_gamecode_test_test_stack_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/main.c b/libs/gamecode/test/main.c index 4e231b5e0..e9256dcec 100644 --- a/libs/gamecode/test/main.c +++ b/libs/gamecode/test/main.c @@ -107,6 +107,21 @@ setup_test (test_t *test) (dstatement_t) { OP_BREAK, 0, 0, 0 }; } +static int +check_result (test_t *test) +{ + int ret = 0; + + if (memcmp (test_pr.pr_globals, test->expect_globals, + test->num_globals * sizeof (pr_int_t)) == 0) { + ret = 1; + printf ("test #%zd: %s: OK\n", test - tests, test->desc); + } else { + printf ("test #%zd: %s: words differ\n", test - tests, test->desc); + } + return ret; +} + static int run_test (test_t *test) { @@ -120,13 +135,7 @@ run_test (test_t *test) printf ("returned from progs\n"); } if (jump_ret == 1) { - if (memcmp (test_pr.pr_globals, test->expect_globals, - test->num_globals * sizeof (pr_int_t)) == 0) { - ret = 1; - printf ("test #%zd: %s: OK\n", test - tests, test->desc); - } else { - printf ("test #%zd: %s: words differ\n", test - tests, test->desc); - } + ret = check_result (test); } else { printf ("test #%zd: %s: critical failure\n", test - tests, test->desc); } diff --git a/libs/gamecode/test/test-math.c b/libs/gamecode/test/test-math.c new file mode 100644 index 000000000..b5daab225 --- /dev/null +++ b/libs/gamecode/test/test-math.c @@ -0,0 +1,77 @@ +#include "head.c" + +static pr_vec4_t float_globals_init[] = { + {3, 4, 5, 12}, + {0, 0, 0, 0}, + {1, 2, 3, 8}, + {4, 5, 6, 8}, + {0, 0, 0, 7}, + {0, 0, 0, 7}, + {1, 2, 3, 4}, + {5, 6, 7, 8}, + {2, 3, 4, 0}, + {0, 0, 0, 0}, + {0, 0, 0, 0}, + {0, 0, 0, 7}, + {0, 0, 0, 7}, + {0, 0, 0, 7}, + {0, 0, 0, 7}, + {0, 0, 0, 0}, + {0, 0, 0, 0}, +}; + +static pr_vec4_t float_globals_expect[] = { + {3, 4, 5, 12}, + {63, 63, -33, 56}, + {1, 2, 3, 8}, + {4, 5, 6, 8}, + + {32, 32, 32, 7}, + {-3, 6, -3, 7}, + {1, 2, 3, 4}, + {5, 6, 7, 8}, + + {2, 3, 4, 0}, + {70, 70, 70, 70}, + {24, 48, 48, -6}, + {36, 102, 120, 7}, + + {52, 70, 136, 7}, + {160, 160, 160, 160}, + {9, 10, 17, 20}, + {-1, -2, -3, 4}, + + {-1, -2, -3, 4}, +}; + +static dstatement_t store_A_statements[] = { + { OP(0, 0, 0, OP_DOT_CC_F), 0, 2, 4 }, + { OP(0, 0, 0, OP_MUL_CC_F), 0, 2, 6 }, + { OP(0, 0, 0, OP_DOT_VV_F), 8, 12, 16 }, + { OP(0, 0, 0, OP_CROSS_VV_F), 8, 12, 20 }, + { OP(0, 0, 0, OP_DOT_QQ_F), 24, 28, 36 }, + { OP(0, 0, 0, OP_MUL_QQ_F), 24, 28, 40 }, + { OP(0, 0, 0, OP_MUL_QV_F), 24, 32, 44 }, + { OP(0, 0, 0, OP_MUL_VQ_F), 32, 24, 48 }, + + { OP(0, 0, 0, OP_DOT_QQ_F), 24, 32, 52 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 24, 0x07e4, 60 }, + { OP(0, 0, 0, OP_DOT_QQ_F), 52, 60, 52 }, + + { OP(0, 0, 0, OP_SWIZZLE_F), 24, 0x07e4, 64 }, + { OP(0, 0, 0, OP_MUL_QQ_F), 60, 32, 56 }, + { OP(0, 0, 0, OP_DOT_QQ_F), 56, 24, 52 }, +}; + +test_t tests[] = { + { + .desc = "float vector", + .num_globals = 4*num_globals(float_globals_init, float_globals_expect), + .num_statements = num_statements (store_A_statements), + .statements = store_A_statements, + .init_globals = (pr_int_t *) float_globals_init, + .expect_globals = (pr_int_t *) float_globals_expect, + }, +}; + +#include "main.c" From bebc811f11dd8a8f6477eefb32075a346185f07b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 19:30:32 +0900 Subject: [PATCH 026/360] [gamecode] Implement 4-component 32-bit swizzle The swizzle instruction is very powerful in that in can do any of the 256 permutations of xyzw, optionally negate any combination of the resulting components, and zero any combination of the result components (even all). This means the one instruction can take care of any actual swizzles, conjugation for complex and quaternion values, zeroing vectors (not that it's the only way), and probably other weird things. The python file was used to generate the jump table and actual swizzle code. --- libs/gamecode/pr_exec.c | 376 +++++++++++++++++++++++++++++++++++++++ libs/gamecode/swizzle.py | 21 +++ 2 files changed, 397 insertions(+) create mode 100644 libs/gamecode/swizzle.py diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 1e41cbe30..040d18b1d 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1870,6 +1870,379 @@ pr_stack_pop (progs_t *pr) return stk; } +static pr_ivec4_t +pr_swizzle_f (pr_ivec4_t vec, pr_ushort_t swiz) +{ + goto do_swizzle; +#define swizzle __builtin_shuffle + swizzle_xxxx: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 0, 0 }); goto negate; + swizzle_yxxx: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 0, 0 }); goto negate; + swizzle_zxxx: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 0, 0 }); goto negate; + swizzle_wxxx: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 0, 0 }); goto negate; + swizzle_xyxx: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 0, 0 }); goto negate; + swizzle_yyxx: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 0, 0 }); goto negate; + swizzle_zyxx: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 0, 0 }); goto negate; + swizzle_wyxx: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 0, 0 }); goto negate; + swizzle_xzxx: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 0, 0 }); goto negate; + swizzle_yzxx: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 0, 0 }); goto negate; + swizzle_zzxx: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 0, 0 }); goto negate; + swizzle_wzxx: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 0, 0 }); goto negate; + swizzle_xwxx: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 0, 0 }); goto negate; + swizzle_ywxx: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 0, 0 }); goto negate; + swizzle_zwxx: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 0, 0 }); goto negate; + swizzle_wwxx: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 0, 0 }); goto negate; + swizzle_xxyx: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 1, 0 }); goto negate; + swizzle_yxyx: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 1, 0 }); goto negate; + swizzle_zxyx: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 1, 0 }); goto negate; + swizzle_wxyx: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 1, 0 }); goto negate; + swizzle_xyyx: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 1, 0 }); goto negate; + swizzle_yyyx: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 1, 0 }); goto negate; + swizzle_zyyx: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 1, 0 }); goto negate; + swizzle_wyyx: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 1, 0 }); goto negate; + swizzle_xzyx: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 1, 0 }); goto negate; + swizzle_yzyx: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 1, 0 }); goto negate; + swizzle_zzyx: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 1, 0 }); goto negate; + swizzle_wzyx: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 1, 0 }); goto negate; + swizzle_xwyx: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 1, 0 }); goto negate; + swizzle_ywyx: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 1, 0 }); goto negate; + swizzle_zwyx: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 1, 0 }); goto negate; + swizzle_wwyx: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 1, 0 }); goto negate; + swizzle_xxzx: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 2, 0 }); goto negate; + swizzle_yxzx: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 2, 0 }); goto negate; + swizzle_zxzx: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 2, 0 }); goto negate; + swizzle_wxzx: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 2, 0 }); goto negate; + swizzle_xyzx: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 2, 0 }); goto negate; + swizzle_yyzx: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 2, 0 }); goto negate; + swizzle_zyzx: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 2, 0 }); goto negate; + swizzle_wyzx: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 2, 0 }); goto negate; + swizzle_xzzx: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 2, 0 }); goto negate; + swizzle_yzzx: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 2, 0 }); goto negate; + swizzle_zzzx: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 2, 0 }); goto negate; + swizzle_wzzx: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 2, 0 }); goto negate; + swizzle_xwzx: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 2, 0 }); goto negate; + swizzle_ywzx: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 2, 0 }); goto negate; + swizzle_zwzx: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 2, 0 }); goto negate; + swizzle_wwzx: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 2, 0 }); goto negate; + swizzle_xxwx: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 3, 0 }); goto negate; + swizzle_yxwx: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 3, 0 }); goto negate; + swizzle_zxwx: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 3, 0 }); goto negate; + swizzle_wxwx: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 3, 0 }); goto negate; + swizzle_xywx: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 3, 0 }); goto negate; + swizzle_yywx: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 3, 0 }); goto negate; + swizzle_zywx: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 3, 0 }); goto negate; + swizzle_wywx: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 3, 0 }); goto negate; + swizzle_xzwx: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 3, 0 }); goto negate; + swizzle_yzwx: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 3, 0 }); goto negate; + swizzle_zzwx: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 3, 0 }); goto negate; + swizzle_wzwx: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 3, 0 }); goto negate; + swizzle_xwwx: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 3, 0 }); goto negate; + swizzle_ywwx: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 3, 0 }); goto negate; + swizzle_zwwx: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 3, 0 }); goto negate; + swizzle_wwwx: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 3, 0 }); goto negate; + swizzle_xxxy: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 0, 1 }); goto negate; + swizzle_yxxy: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 0, 1 }); goto negate; + swizzle_zxxy: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 0, 1 }); goto negate; + swizzle_wxxy: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 0, 1 }); goto negate; + swizzle_xyxy: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 0, 1 }); goto negate; + swizzle_yyxy: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 0, 1 }); goto negate; + swizzle_zyxy: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 0, 1 }); goto negate; + swizzle_wyxy: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 0, 1 }); goto negate; + swizzle_xzxy: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 0, 1 }); goto negate; + swizzle_yzxy: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 0, 1 }); goto negate; + swizzle_zzxy: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 0, 1 }); goto negate; + swizzle_wzxy: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 0, 1 }); goto negate; + swizzle_xwxy: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 0, 1 }); goto negate; + swizzle_ywxy: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 0, 1 }); goto negate; + swizzle_zwxy: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 0, 1 }); goto negate; + swizzle_wwxy: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 0, 1 }); goto negate; + swizzle_xxyy: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 1, 1 }); goto negate; + swizzle_yxyy: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 1, 1 }); goto negate; + swizzle_zxyy: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 1, 1 }); goto negate; + swizzle_wxyy: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 1, 1 }); goto negate; + swizzle_xyyy: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 1, 1 }); goto negate; + swizzle_yyyy: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 1, 1 }); goto negate; + swizzle_zyyy: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 1, 1 }); goto negate; + swizzle_wyyy: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 1, 1 }); goto negate; + swizzle_xzyy: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 1, 1 }); goto negate; + swizzle_yzyy: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 1, 1 }); goto negate; + swizzle_zzyy: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 1, 1 }); goto negate; + swizzle_wzyy: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 1, 1 }); goto negate; + swizzle_xwyy: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 1, 1 }); goto negate; + swizzle_ywyy: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 1, 1 }); goto negate; + swizzle_zwyy: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 1, 1 }); goto negate; + swizzle_wwyy: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 1, 1 }); goto negate; + swizzle_xxzy: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 2, 1 }); goto negate; + swizzle_yxzy: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 2, 1 }); goto negate; + swizzle_zxzy: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 2, 1 }); goto negate; + swizzle_wxzy: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 2, 1 }); goto negate; + swizzle_xyzy: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 2, 1 }); goto negate; + swizzle_yyzy: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 2, 1 }); goto negate; + swizzle_zyzy: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 2, 1 }); goto negate; + swizzle_wyzy: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 2, 1 }); goto negate; + swizzle_xzzy: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 2, 1 }); goto negate; + swizzle_yzzy: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 2, 1 }); goto negate; + swizzle_zzzy: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 2, 1 }); goto negate; + swizzle_wzzy: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 2, 1 }); goto negate; + swizzle_xwzy: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 2, 1 }); goto negate; + swizzle_ywzy: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 2, 1 }); goto negate; + swizzle_zwzy: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 2, 1 }); goto negate; + swizzle_wwzy: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 2, 1 }); goto negate; + swizzle_xxwy: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 3, 1 }); goto negate; + swizzle_yxwy: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 3, 1 }); goto negate; + swizzle_zxwy: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 3, 1 }); goto negate; + swizzle_wxwy: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 3, 1 }); goto negate; + swizzle_xywy: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 3, 1 }); goto negate; + swizzle_yywy: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 3, 1 }); goto negate; + swizzle_zywy: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 3, 1 }); goto negate; + swizzle_wywy: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 3, 1 }); goto negate; + swizzle_xzwy: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 3, 1 }); goto negate; + swizzle_yzwy: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 3, 1 }); goto negate; + swizzle_zzwy: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 3, 1 }); goto negate; + swizzle_wzwy: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 3, 1 }); goto negate; + swizzle_xwwy: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 3, 1 }); goto negate; + swizzle_ywwy: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 3, 1 }); goto negate; + swizzle_zwwy: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 3, 1 }); goto negate; + swizzle_wwwy: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 3, 1 }); goto negate; + swizzle_xxxz: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 0, 2 }); goto negate; + swizzle_yxxz: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 0, 2 }); goto negate; + swizzle_zxxz: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 0, 2 }); goto negate; + swizzle_wxxz: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 0, 2 }); goto negate; + swizzle_xyxz: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 0, 2 }); goto negate; + swizzle_yyxz: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 0, 2 }); goto negate; + swizzle_zyxz: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 0, 2 }); goto negate; + swizzle_wyxz: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 0, 2 }); goto negate; + swizzle_xzxz: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 0, 2 }); goto negate; + swizzle_yzxz: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 0, 2 }); goto negate; + swizzle_zzxz: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 0, 2 }); goto negate; + swizzle_wzxz: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 0, 2 }); goto negate; + swizzle_xwxz: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 0, 2 }); goto negate; + swizzle_ywxz: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 0, 2 }); goto negate; + swizzle_zwxz: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 0, 2 }); goto negate; + swizzle_wwxz: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 0, 2 }); goto negate; + swizzle_xxyz: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 1, 2 }); goto negate; + swizzle_yxyz: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 1, 2 }); goto negate; + swizzle_zxyz: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 1, 2 }); goto negate; + swizzle_wxyz: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 1, 2 }); goto negate; + swizzle_xyyz: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 1, 2 }); goto negate; + swizzle_yyyz: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 1, 2 }); goto negate; + swizzle_zyyz: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 1, 2 }); goto negate; + swizzle_wyyz: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 1, 2 }); goto negate; + swizzle_xzyz: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 1, 2 }); goto negate; + swizzle_yzyz: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 1, 2 }); goto negate; + swizzle_zzyz: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 1, 2 }); goto negate; + swizzle_wzyz: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 1, 2 }); goto negate; + swizzle_xwyz: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 1, 2 }); goto negate; + swizzle_ywyz: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 1, 2 }); goto negate; + swizzle_zwyz: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 1, 2 }); goto negate; + swizzle_wwyz: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 1, 2 }); goto negate; + swizzle_xxzz: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 2, 2 }); goto negate; + swizzle_yxzz: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 2, 2 }); goto negate; + swizzle_zxzz: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 2, 2 }); goto negate; + swizzle_wxzz: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 2, 2 }); goto negate; + swizzle_xyzz: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 2, 2 }); goto negate; + swizzle_yyzz: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 2, 2 }); goto negate; + swizzle_zyzz: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 2, 2 }); goto negate; + swizzle_wyzz: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 2, 2 }); goto negate; + swizzle_xzzz: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 2, 2 }); goto negate; + swizzle_yzzz: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 2, 2 }); goto negate; + swizzle_zzzz: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 2, 2 }); goto negate; + swizzle_wzzz: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 2, 2 }); goto negate; + swizzle_xwzz: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 2, 2 }); goto negate; + swizzle_ywzz: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 2, 2 }); goto negate; + swizzle_zwzz: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 2, 2 }); goto negate; + swizzle_wwzz: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 2, 2 }); goto negate; + swizzle_xxwz: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 3, 2 }); goto negate; + swizzle_yxwz: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 3, 2 }); goto negate; + swizzle_zxwz: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 3, 2 }); goto negate; + swizzle_wxwz: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 3, 2 }); goto negate; + swizzle_xywz: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 3, 2 }); goto negate; + swizzle_yywz: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 3, 2 }); goto negate; + swizzle_zywz: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 3, 2 }); goto negate; + swizzle_wywz: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 3, 2 }); goto negate; + swizzle_xzwz: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 3, 2 }); goto negate; + swizzle_yzwz: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 3, 2 }); goto negate; + swizzle_zzwz: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 3, 2 }); goto negate; + swizzle_wzwz: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 3, 2 }); goto negate; + swizzle_xwwz: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 3, 2 }); goto negate; + swizzle_ywwz: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 3, 2 }); goto negate; + swizzle_zwwz: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 3, 2 }); goto negate; + swizzle_wwwz: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 3, 2 }); goto negate; + swizzle_xxxw: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 0, 3 }); goto negate; + swizzle_yxxw: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 0, 3 }); goto negate; + swizzle_zxxw: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 0, 3 }); goto negate; + swizzle_wxxw: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 0, 3 }); goto negate; + swizzle_xyxw: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 0, 3 }); goto negate; + swizzle_yyxw: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 0, 3 }); goto negate; + swizzle_zyxw: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 0, 3 }); goto negate; + swizzle_wyxw: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 0, 3 }); goto negate; + swizzle_xzxw: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 0, 3 }); goto negate; + swizzle_yzxw: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 0, 3 }); goto negate; + swizzle_zzxw: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 0, 3 }); goto negate; + swizzle_wzxw: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 0, 3 }); goto negate; + swizzle_xwxw: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 0, 3 }); goto negate; + swizzle_ywxw: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 0, 3 }); goto negate; + swizzle_zwxw: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 0, 3 }); goto negate; + swizzle_wwxw: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 0, 3 }); goto negate; + swizzle_xxyw: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 1, 3 }); goto negate; + swizzle_yxyw: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 1, 3 }); goto negate; + swizzle_zxyw: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 1, 3 }); goto negate; + swizzle_wxyw: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 1, 3 }); goto negate; + swizzle_xyyw: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 1, 3 }); goto negate; + swizzle_yyyw: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 1, 3 }); goto negate; + swizzle_zyyw: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 1, 3 }); goto negate; + swizzle_wyyw: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 1, 3 }); goto negate; + swizzle_xzyw: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 1, 3 }); goto negate; + swizzle_yzyw: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 1, 3 }); goto negate; + swizzle_zzyw: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 1, 3 }); goto negate; + swizzle_wzyw: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 1, 3 }); goto negate; + swizzle_xwyw: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 1, 3 }); goto negate; + swizzle_ywyw: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 1, 3 }); goto negate; + swizzle_zwyw: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 1, 3 }); goto negate; + swizzle_wwyw: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 1, 3 }); goto negate; + swizzle_xxzw: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 2, 3 }); goto negate; + swizzle_yxzw: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 2, 3 }); goto negate; + swizzle_zxzw: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 2, 3 }); goto negate; + swizzle_wxzw: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 2, 3 }); goto negate; + swizzle_xyzw: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 2, 3 }); goto negate; + swizzle_yyzw: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 2, 3 }); goto negate; + swizzle_zyzw: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 2, 3 }); goto negate; + swizzle_wyzw: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 2, 3 }); goto negate; + swizzle_xzzw: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 2, 3 }); goto negate; + swizzle_yzzw: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 2, 3 }); goto negate; + swizzle_zzzw: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 2, 3 }); goto negate; + swizzle_wzzw: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 2, 3 }); goto negate; + swizzle_xwzw: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 2, 3 }); goto negate; + swizzle_ywzw: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 2, 3 }); goto negate; + swizzle_zwzw: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 2, 3 }); goto negate; + swizzle_wwzw: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 2, 3 }); goto negate; + swizzle_xxww: vec = swizzle (vec, (pr_ivec4_t) { 0, 0, 3, 3 }); goto negate; + swizzle_yxww: vec = swizzle (vec, (pr_ivec4_t) { 1, 0, 3, 3 }); goto negate; + swizzle_zxww: vec = swizzle (vec, (pr_ivec4_t) { 2, 0, 3, 3 }); goto negate; + swizzle_wxww: vec = swizzle (vec, (pr_ivec4_t) { 3, 0, 3, 3 }); goto negate; + swizzle_xyww: vec = swizzle (vec, (pr_ivec4_t) { 0, 1, 3, 3 }); goto negate; + swizzle_yyww: vec = swizzle (vec, (pr_ivec4_t) { 1, 1, 3, 3 }); goto negate; + swizzle_zyww: vec = swizzle (vec, (pr_ivec4_t) { 2, 1, 3, 3 }); goto negate; + swizzle_wyww: vec = swizzle (vec, (pr_ivec4_t) { 3, 1, 3, 3 }); goto negate; + swizzle_xzww: vec = swizzle (vec, (pr_ivec4_t) { 0, 2, 3, 3 }); goto negate; + swizzle_yzww: vec = swizzle (vec, (pr_ivec4_t) { 1, 2, 3, 3 }); goto negate; + swizzle_zzww: vec = swizzle (vec, (pr_ivec4_t) { 2, 2, 3, 3 }); goto negate; + swizzle_wzww: vec = swizzle (vec, (pr_ivec4_t) { 3, 2, 3, 3 }); goto negate; + swizzle_xwww: vec = swizzle (vec, (pr_ivec4_t) { 0, 3, 3, 3 }); goto negate; + swizzle_ywww: vec = swizzle (vec, (pr_ivec4_t) { 1, 3, 3, 3 }); goto negate; + swizzle_zwww: vec = swizzle (vec, (pr_ivec4_t) { 2, 3, 3, 3 }); goto negate; + swizzle_wwww: vec = swizzle (vec, (pr_ivec4_t) { 3, 3, 3, 3 }); goto negate; + static void *swizzle_table[256] = { + &&swizzle_xxxx, &&swizzle_yxxx, &&swizzle_zxxx, &&swizzle_wxxx, + &&swizzle_xyxx, &&swizzle_yyxx, &&swizzle_zyxx, &&swizzle_wyxx, + &&swizzle_xzxx, &&swizzle_yzxx, &&swizzle_zzxx, &&swizzle_wzxx, + &&swizzle_xwxx, &&swizzle_ywxx, &&swizzle_zwxx, &&swizzle_wwxx, + &&swizzle_xxyx, &&swizzle_yxyx, &&swizzle_zxyx, &&swizzle_wxyx, + &&swizzle_xyyx, &&swizzle_yyyx, &&swizzle_zyyx, &&swizzle_wyyx, + &&swizzle_xzyx, &&swizzle_yzyx, &&swizzle_zzyx, &&swizzle_wzyx, + &&swizzle_xwyx, &&swizzle_ywyx, &&swizzle_zwyx, &&swizzle_wwyx, + &&swizzle_xxzx, &&swizzle_yxzx, &&swizzle_zxzx, &&swizzle_wxzx, + &&swizzle_xyzx, &&swizzle_yyzx, &&swizzle_zyzx, &&swizzle_wyzx, + &&swizzle_xzzx, &&swizzle_yzzx, &&swizzle_zzzx, &&swizzle_wzzx, + &&swizzle_xwzx, &&swizzle_ywzx, &&swizzle_zwzx, &&swizzle_wwzx, + &&swizzle_xxwx, &&swizzle_yxwx, &&swizzle_zxwx, &&swizzle_wxwx, + &&swizzle_xywx, &&swizzle_yywx, &&swizzle_zywx, &&swizzle_wywx, + &&swizzle_xzwx, &&swizzle_yzwx, &&swizzle_zzwx, &&swizzle_wzwx, + &&swizzle_xwwx, &&swizzle_ywwx, &&swizzle_zwwx, &&swizzle_wwwx, + &&swizzle_xxxy, &&swizzle_yxxy, &&swizzle_zxxy, &&swizzle_wxxy, + &&swizzle_xyxy, &&swizzle_yyxy, &&swizzle_zyxy, &&swizzle_wyxy, + &&swizzle_xzxy, &&swizzle_yzxy, &&swizzle_zzxy, &&swizzle_wzxy, + &&swizzle_xwxy, &&swizzle_ywxy, &&swizzle_zwxy, &&swizzle_wwxy, + &&swizzle_xxyy, &&swizzle_yxyy, &&swizzle_zxyy, &&swizzle_wxyy, + &&swizzle_xyyy, &&swizzle_yyyy, &&swizzle_zyyy, &&swizzle_wyyy, + &&swizzle_xzyy, &&swizzle_yzyy, &&swizzle_zzyy, &&swizzle_wzyy, + &&swizzle_xwyy, &&swizzle_ywyy, &&swizzle_zwyy, &&swizzle_wwyy, + &&swizzle_xxzy, &&swizzle_yxzy, &&swizzle_zxzy, &&swizzle_wxzy, + &&swizzle_xyzy, &&swizzle_yyzy, &&swizzle_zyzy, &&swizzle_wyzy, + &&swizzle_xzzy, &&swizzle_yzzy, &&swizzle_zzzy, &&swizzle_wzzy, + &&swizzle_xwzy, &&swizzle_ywzy, &&swizzle_zwzy, &&swizzle_wwzy, + &&swizzle_xxwy, &&swizzle_yxwy, &&swizzle_zxwy, &&swizzle_wxwy, + &&swizzle_xywy, &&swizzle_yywy, &&swizzle_zywy, &&swizzle_wywy, + &&swizzle_xzwy, &&swizzle_yzwy, &&swizzle_zzwy, &&swizzle_wzwy, + &&swizzle_xwwy, &&swizzle_ywwy, &&swizzle_zwwy, &&swizzle_wwwy, + &&swizzle_xxxz, &&swizzle_yxxz, &&swizzle_zxxz, &&swizzle_wxxz, + &&swizzle_xyxz, &&swizzle_yyxz, &&swizzle_zyxz, &&swizzle_wyxz, + &&swizzle_xzxz, &&swizzle_yzxz, &&swizzle_zzxz, &&swizzle_wzxz, + &&swizzle_xwxz, &&swizzle_ywxz, &&swizzle_zwxz, &&swizzle_wwxz, + &&swizzle_xxyz, &&swizzle_yxyz, &&swizzle_zxyz, &&swizzle_wxyz, + &&swizzle_xyyz, &&swizzle_yyyz, &&swizzle_zyyz, &&swizzle_wyyz, + &&swizzle_xzyz, &&swizzle_yzyz, &&swizzle_zzyz, &&swizzle_wzyz, + &&swizzle_xwyz, &&swizzle_ywyz, &&swizzle_zwyz, &&swizzle_wwyz, + &&swizzle_xxzz, &&swizzle_yxzz, &&swizzle_zxzz, &&swizzle_wxzz, + &&swizzle_xyzz, &&swizzle_yyzz, &&swizzle_zyzz, &&swizzle_wyzz, + &&swizzle_xzzz, &&swizzle_yzzz, &&swizzle_zzzz, &&swizzle_wzzz, + &&swizzle_xwzz, &&swizzle_ywzz, &&swizzle_zwzz, &&swizzle_wwzz, + &&swizzle_xxwz, &&swizzle_yxwz, &&swizzle_zxwz, &&swizzle_wxwz, + &&swizzle_xywz, &&swizzle_yywz, &&swizzle_zywz, &&swizzle_wywz, + &&swizzle_xzwz, &&swizzle_yzwz, &&swizzle_zzwz, &&swizzle_wzwz, + &&swizzle_xwwz, &&swizzle_ywwz, &&swizzle_zwwz, &&swizzle_wwwz, + &&swizzle_xxxw, &&swizzle_yxxw, &&swizzle_zxxw, &&swizzle_wxxw, + &&swizzle_xyxw, &&swizzle_yyxw, &&swizzle_zyxw, &&swizzle_wyxw, + &&swizzle_xzxw, &&swizzle_yzxw, &&swizzle_zzxw, &&swizzle_wzxw, + &&swizzle_xwxw, &&swizzle_ywxw, &&swizzle_zwxw, &&swizzle_wwxw, + &&swizzle_xxyw, &&swizzle_yxyw, &&swizzle_zxyw, &&swizzle_wxyw, + &&swizzle_xyyw, &&swizzle_yyyw, &&swizzle_zyyw, &&swizzle_wyyw, + &&swizzle_xzyw, &&swizzle_yzyw, &&swizzle_zzyw, &&swizzle_wzyw, + &&swizzle_xwyw, &&swizzle_ywyw, &&swizzle_zwyw, &&swizzle_wwyw, + &&swizzle_xxzw, &&swizzle_yxzw, &&swizzle_zxzw, &&swizzle_wxzw, + &&swizzle_xyzw, &&swizzle_yyzw, &&swizzle_zyzw, &&swizzle_wyzw, + &&swizzle_xzzw, &&swizzle_yzzw, &&swizzle_zzzw, &&swizzle_wzzw, + &&swizzle_xwzw, &&swizzle_ywzw, &&swizzle_zwzw, &&swizzle_wwzw, + &&swizzle_xxww, &&swizzle_yxww, &&swizzle_zxww, &&swizzle_wxww, + &&swizzle_xyww, &&swizzle_yyww, &&swizzle_zyww, &&swizzle_wyww, + &&swizzle_xzww, &&swizzle_yzww, &&swizzle_zzww, &&swizzle_wzww, + &&swizzle_xwww, &&swizzle_ywww, &&swizzle_zwww, &&swizzle_wwww, + }; +#undef swizzle + static const pr_ivec4_t neg[16] = { + { 0, 0, 0, 0 }, + { 1<<31, 0, 0, 0 }, + { 0, 1<<31, 0, 0 }, + { 1<<31, 1<<31, 0, 0 }, + { 0, 0, 1<<31, 0 }, + { 1<<31, 0, 1<<31, 0 }, + { 0, 1<<31, 1<<31, 0 }, + { 1<<31, 1<<31, 1<<31, 0 }, + { 0, 0, 0, 1<<31 }, + { 1<<31, 0, 0, 1<<31 }, + { 0, 1<<31, 0, 1<<31 }, + { 1<<31, 1<<31, 0, 1<<31 }, + { 0, 0, 1<<31, 1<<31 }, + { 1<<31, 0, 1<<31, 1<<31 }, + { 0, 1<<31, 1<<31, 1<<31 }, + { 1<<31, 1<<31, 1<<31, 1<<31 }, + }; + static const pr_ivec4_t zero[16] = { + { ~0, ~0, ~0, ~0 }, + { 0, ~0, ~0, ~0 }, + { ~0, 0, ~0, ~0 }, + { 0, 0, ~0, ~0 }, + { ~0, ~0, 0, ~0 }, + { 0, ~0, 0, ~0 }, + { ~0, 0, 0, ~0 }, + { 0, 0, 0, ~0 }, + { ~0, ~0, ~0, 0 }, + { 0, ~0, ~0, 0 }, + { ~0, 0, ~0, 0 }, + { 0, 0, ~0, 0 }, + { ~0, ~0, 0, 0 }, + { 0, ~0, 0, 0 }, + { ~0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + }; + +do_swizzle: + goto *swizzle_table[swiz & 0xff]; +negate: + vec ^= neg[(swiz >> 8) & 0xf]; + vec &= zero[(swiz >> 12) & 0xf]; + return vec; +} + static void pr_exec_ruamoko (progs_t *pr, int exitdepth) { @@ -2616,6 +2989,9 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) break; // 1 1110 OP_op_T (LE, u, uint, uivec2, uivec4, <=); + case OP_SWIZZLE_F: + OPC(ivec4) = pr_swizzle_f (OPA(ivec4), st->b); + break; //FIXME misc ops OP_op_T (LE, U, ulong, ulvec2, ulvec4, <=); //FIXME misc ops diff --git a/libs/gamecode/swizzle.py b/libs/gamecode/swizzle.py new file mode 100644 index 000000000..673f5aec4 --- /dev/null +++ b/libs/gamecode/swizzle.py @@ -0,0 +1,21 @@ +def iter(func): + for i in range(4): + for j in range(4): + for k in range(4): + for l in range(4): + func(i, j, k, l) + +coord=['x', 'y', 'z', 'w'] +def label(i, j, k, l): + return f"swizzle_{coord[l]}{coord[k]}{coord[j]}{coord[i]}" + +def print_ref(i, j, k, l): + print(f"\t\t&&{label(i, j, k, l)},") + +def print_op(i, j, k, l): + print(f"\t{label(i, j, k, l)}: vec = swizzle (vec, (pr_ivec4_t) {{ {l}, {k}, {j}, {i} }}); goto negate;") + +iter(print_op) +print("\tstatic void *swizzle_table[256] = {") +iter(print_ref) +print("\t};") From b6f9b6843472ae97daac2e6e20e4e64ef4d09095 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 19:55:27 +0900 Subject: [PATCH 027/360] [gamecode] Implement 64-bit swizzles See commit for 32-bit swizzles. --- libs/gamecode/pr_exec.c | 376 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 376 insertions(+) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 040d18b1d..1f8541ed8 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -2243,6 +2243,379 @@ negate: return vec; } +static pr_lvec4_t +pr_swizzle_d (pr_lvec4_t vec, pr_ushort_t swiz) +{ + goto do_swizzle; +#define swizzle __builtin_shuffle + swizzle_xxxx: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 0, 0 }); goto negate; + swizzle_yxxx: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 0, 0 }); goto negate; + swizzle_zxxx: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 0, 0 }); goto negate; + swizzle_wxxx: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 0, 0 }); goto negate; + swizzle_xyxx: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 0, 0 }); goto negate; + swizzle_yyxx: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 0, 0 }); goto negate; + swizzle_zyxx: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 0, 0 }); goto negate; + swizzle_wyxx: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 0, 0 }); goto negate; + swizzle_xzxx: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 0, 0 }); goto negate; + swizzle_yzxx: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 0, 0 }); goto negate; + swizzle_zzxx: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 0, 0 }); goto negate; + swizzle_wzxx: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 0, 0 }); goto negate; + swizzle_xwxx: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 0, 0 }); goto negate; + swizzle_ywxx: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 0, 0 }); goto negate; + swizzle_zwxx: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 0, 0 }); goto negate; + swizzle_wwxx: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 0, 0 }); goto negate; + swizzle_xxyx: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 1, 0 }); goto negate; + swizzle_yxyx: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 1, 0 }); goto negate; + swizzle_zxyx: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 1, 0 }); goto negate; + swizzle_wxyx: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 1, 0 }); goto negate; + swizzle_xyyx: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 1, 0 }); goto negate; + swizzle_yyyx: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 1, 0 }); goto negate; + swizzle_zyyx: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 1, 0 }); goto negate; + swizzle_wyyx: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 1, 0 }); goto negate; + swizzle_xzyx: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 1, 0 }); goto negate; + swizzle_yzyx: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 1, 0 }); goto negate; + swizzle_zzyx: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 1, 0 }); goto negate; + swizzle_wzyx: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 1, 0 }); goto negate; + swizzle_xwyx: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 1, 0 }); goto negate; + swizzle_ywyx: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 1, 0 }); goto negate; + swizzle_zwyx: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 1, 0 }); goto negate; + swizzle_wwyx: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 1, 0 }); goto negate; + swizzle_xxzx: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 2, 0 }); goto negate; + swizzle_yxzx: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 2, 0 }); goto negate; + swizzle_zxzx: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 2, 0 }); goto negate; + swizzle_wxzx: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 2, 0 }); goto negate; + swizzle_xyzx: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 2, 0 }); goto negate; + swizzle_yyzx: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 2, 0 }); goto negate; + swizzle_zyzx: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 2, 0 }); goto negate; + swizzle_wyzx: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 2, 0 }); goto negate; + swizzle_xzzx: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 2, 0 }); goto negate; + swizzle_yzzx: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 2, 0 }); goto negate; + swizzle_zzzx: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 2, 0 }); goto negate; + swizzle_wzzx: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 2, 0 }); goto negate; + swizzle_xwzx: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 2, 0 }); goto negate; + swizzle_ywzx: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 2, 0 }); goto negate; + swizzle_zwzx: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 2, 0 }); goto negate; + swizzle_wwzx: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 2, 0 }); goto negate; + swizzle_xxwx: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 3, 0 }); goto negate; + swizzle_yxwx: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 3, 0 }); goto negate; + swizzle_zxwx: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 3, 0 }); goto negate; + swizzle_wxwx: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 3, 0 }); goto negate; + swizzle_xywx: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 3, 0 }); goto negate; + swizzle_yywx: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 3, 0 }); goto negate; + swizzle_zywx: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 3, 0 }); goto negate; + swizzle_wywx: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 3, 0 }); goto negate; + swizzle_xzwx: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 3, 0 }); goto negate; + swizzle_yzwx: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 3, 0 }); goto negate; + swizzle_zzwx: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 3, 0 }); goto negate; + swizzle_wzwx: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 3, 0 }); goto negate; + swizzle_xwwx: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 3, 0 }); goto negate; + swizzle_ywwx: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 3, 0 }); goto negate; + swizzle_zwwx: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 3, 0 }); goto negate; + swizzle_wwwx: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 3, 0 }); goto negate; + swizzle_xxxy: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 0, 1 }); goto negate; + swizzle_yxxy: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 0, 1 }); goto negate; + swizzle_zxxy: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 0, 1 }); goto negate; + swizzle_wxxy: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 0, 1 }); goto negate; + swizzle_xyxy: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 0, 1 }); goto negate; + swizzle_yyxy: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 0, 1 }); goto negate; + swizzle_zyxy: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 0, 1 }); goto negate; + swizzle_wyxy: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 0, 1 }); goto negate; + swizzle_xzxy: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 0, 1 }); goto negate; + swizzle_yzxy: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 0, 1 }); goto negate; + swizzle_zzxy: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 0, 1 }); goto negate; + swizzle_wzxy: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 0, 1 }); goto negate; + swizzle_xwxy: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 0, 1 }); goto negate; + swizzle_ywxy: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 0, 1 }); goto negate; + swizzle_zwxy: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 0, 1 }); goto negate; + swizzle_wwxy: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 0, 1 }); goto negate; + swizzle_xxyy: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 1, 1 }); goto negate; + swizzle_yxyy: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 1, 1 }); goto negate; + swizzle_zxyy: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 1, 1 }); goto negate; + swizzle_wxyy: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 1, 1 }); goto negate; + swizzle_xyyy: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 1, 1 }); goto negate; + swizzle_yyyy: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 1, 1 }); goto negate; + swizzle_zyyy: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 1, 1 }); goto negate; + swizzle_wyyy: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 1, 1 }); goto negate; + swizzle_xzyy: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 1, 1 }); goto negate; + swizzle_yzyy: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 1, 1 }); goto negate; + swizzle_zzyy: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 1, 1 }); goto negate; + swizzle_wzyy: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 1, 1 }); goto negate; + swizzle_xwyy: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 1, 1 }); goto negate; + swizzle_ywyy: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 1, 1 }); goto negate; + swizzle_zwyy: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 1, 1 }); goto negate; + swizzle_wwyy: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 1, 1 }); goto negate; + swizzle_xxzy: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 2, 1 }); goto negate; + swizzle_yxzy: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 2, 1 }); goto negate; + swizzle_zxzy: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 2, 1 }); goto negate; + swizzle_wxzy: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 2, 1 }); goto negate; + swizzle_xyzy: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 2, 1 }); goto negate; + swizzle_yyzy: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 2, 1 }); goto negate; + swizzle_zyzy: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 2, 1 }); goto negate; + swizzle_wyzy: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 2, 1 }); goto negate; + swizzle_xzzy: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 2, 1 }); goto negate; + swizzle_yzzy: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 2, 1 }); goto negate; + swizzle_zzzy: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 2, 1 }); goto negate; + swizzle_wzzy: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 2, 1 }); goto negate; + swizzle_xwzy: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 2, 1 }); goto negate; + swizzle_ywzy: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 2, 1 }); goto negate; + swizzle_zwzy: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 2, 1 }); goto negate; + swizzle_wwzy: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 2, 1 }); goto negate; + swizzle_xxwy: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 3, 1 }); goto negate; + swizzle_yxwy: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 3, 1 }); goto negate; + swizzle_zxwy: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 3, 1 }); goto negate; + swizzle_wxwy: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 3, 1 }); goto negate; + swizzle_xywy: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 3, 1 }); goto negate; + swizzle_yywy: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 3, 1 }); goto negate; + swizzle_zywy: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 3, 1 }); goto negate; + swizzle_wywy: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 3, 1 }); goto negate; + swizzle_xzwy: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 3, 1 }); goto negate; + swizzle_yzwy: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 3, 1 }); goto negate; + swizzle_zzwy: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 3, 1 }); goto negate; + swizzle_wzwy: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 3, 1 }); goto negate; + swizzle_xwwy: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 3, 1 }); goto negate; + swizzle_ywwy: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 3, 1 }); goto negate; + swizzle_zwwy: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 3, 1 }); goto negate; + swizzle_wwwy: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 3, 1 }); goto negate; + swizzle_xxxz: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 0, 2 }); goto negate; + swizzle_yxxz: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 0, 2 }); goto negate; + swizzle_zxxz: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 0, 2 }); goto negate; + swizzle_wxxz: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 0, 2 }); goto negate; + swizzle_xyxz: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 0, 2 }); goto negate; + swizzle_yyxz: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 0, 2 }); goto negate; + swizzle_zyxz: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 0, 2 }); goto negate; + swizzle_wyxz: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 0, 2 }); goto negate; + swizzle_xzxz: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 0, 2 }); goto negate; + swizzle_yzxz: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 0, 2 }); goto negate; + swizzle_zzxz: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 0, 2 }); goto negate; + swizzle_wzxz: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 0, 2 }); goto negate; + swizzle_xwxz: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 0, 2 }); goto negate; + swizzle_ywxz: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 0, 2 }); goto negate; + swizzle_zwxz: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 0, 2 }); goto negate; + swizzle_wwxz: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 0, 2 }); goto negate; + swizzle_xxyz: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 1, 2 }); goto negate; + swizzle_yxyz: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 1, 2 }); goto negate; + swizzle_zxyz: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 1, 2 }); goto negate; + swizzle_wxyz: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 1, 2 }); goto negate; + swizzle_xyyz: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 1, 2 }); goto negate; + swizzle_yyyz: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 1, 2 }); goto negate; + swizzle_zyyz: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 1, 2 }); goto negate; + swizzle_wyyz: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 1, 2 }); goto negate; + swizzle_xzyz: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 1, 2 }); goto negate; + swizzle_yzyz: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 1, 2 }); goto negate; + swizzle_zzyz: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 1, 2 }); goto negate; + swizzle_wzyz: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 1, 2 }); goto negate; + swizzle_xwyz: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 1, 2 }); goto negate; + swizzle_ywyz: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 1, 2 }); goto negate; + swizzle_zwyz: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 1, 2 }); goto negate; + swizzle_wwyz: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 1, 2 }); goto negate; + swizzle_xxzz: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 2, 2 }); goto negate; + swizzle_yxzz: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 2, 2 }); goto negate; + swizzle_zxzz: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 2, 2 }); goto negate; + swizzle_wxzz: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 2, 2 }); goto negate; + swizzle_xyzz: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 2, 2 }); goto negate; + swizzle_yyzz: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 2, 2 }); goto negate; + swizzle_zyzz: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 2, 2 }); goto negate; + swizzle_wyzz: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 2, 2 }); goto negate; + swizzle_xzzz: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 2, 2 }); goto negate; + swizzle_yzzz: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 2, 2 }); goto negate; + swizzle_zzzz: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 2, 2 }); goto negate; + swizzle_wzzz: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 2, 2 }); goto negate; + swizzle_xwzz: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 2, 2 }); goto negate; + swizzle_ywzz: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 2, 2 }); goto negate; + swizzle_zwzz: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 2, 2 }); goto negate; + swizzle_wwzz: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 2, 2 }); goto negate; + swizzle_xxwz: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 3, 2 }); goto negate; + swizzle_yxwz: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 3, 2 }); goto negate; + swizzle_zxwz: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 3, 2 }); goto negate; + swizzle_wxwz: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 3, 2 }); goto negate; + swizzle_xywz: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 3, 2 }); goto negate; + swizzle_yywz: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 3, 2 }); goto negate; + swizzle_zywz: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 3, 2 }); goto negate; + swizzle_wywz: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 3, 2 }); goto negate; + swizzle_xzwz: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 3, 2 }); goto negate; + swizzle_yzwz: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 3, 2 }); goto negate; + swizzle_zzwz: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 3, 2 }); goto negate; + swizzle_wzwz: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 3, 2 }); goto negate; + swizzle_xwwz: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 3, 2 }); goto negate; + swizzle_ywwz: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 3, 2 }); goto negate; + swizzle_zwwz: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 3, 2 }); goto negate; + swizzle_wwwz: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 3, 2 }); goto negate; + swizzle_xxxw: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 0, 3 }); goto negate; + swizzle_yxxw: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 0, 3 }); goto negate; + swizzle_zxxw: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 0, 3 }); goto negate; + swizzle_wxxw: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 0, 3 }); goto negate; + swizzle_xyxw: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 0, 3 }); goto negate; + swizzle_yyxw: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 0, 3 }); goto negate; + swizzle_zyxw: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 0, 3 }); goto negate; + swizzle_wyxw: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 0, 3 }); goto negate; + swizzle_xzxw: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 0, 3 }); goto negate; + swizzle_yzxw: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 0, 3 }); goto negate; + swizzle_zzxw: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 0, 3 }); goto negate; + swizzle_wzxw: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 0, 3 }); goto negate; + swizzle_xwxw: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 0, 3 }); goto negate; + swizzle_ywxw: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 0, 3 }); goto negate; + swizzle_zwxw: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 0, 3 }); goto negate; + swizzle_wwxw: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 0, 3 }); goto negate; + swizzle_xxyw: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 1, 3 }); goto negate; + swizzle_yxyw: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 1, 3 }); goto negate; + swizzle_zxyw: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 1, 3 }); goto negate; + swizzle_wxyw: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 1, 3 }); goto negate; + swizzle_xyyw: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 1, 3 }); goto negate; + swizzle_yyyw: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 1, 3 }); goto negate; + swizzle_zyyw: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 1, 3 }); goto negate; + swizzle_wyyw: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 1, 3 }); goto negate; + swizzle_xzyw: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 1, 3 }); goto negate; + swizzle_yzyw: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 1, 3 }); goto negate; + swizzle_zzyw: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 1, 3 }); goto negate; + swizzle_wzyw: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 1, 3 }); goto negate; + swizzle_xwyw: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 1, 3 }); goto negate; + swizzle_ywyw: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 1, 3 }); goto negate; + swizzle_zwyw: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 1, 3 }); goto negate; + swizzle_wwyw: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 1, 3 }); goto negate; + swizzle_xxzw: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 2, 3 }); goto negate; + swizzle_yxzw: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 2, 3 }); goto negate; + swizzle_zxzw: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 2, 3 }); goto negate; + swizzle_wxzw: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 2, 3 }); goto negate; + swizzle_xyzw: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 2, 3 }); goto negate; + swizzle_yyzw: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 2, 3 }); goto negate; + swizzle_zyzw: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 2, 3 }); goto negate; + swizzle_wyzw: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 2, 3 }); goto negate; + swizzle_xzzw: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 2, 3 }); goto negate; + swizzle_yzzw: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 2, 3 }); goto negate; + swizzle_zzzw: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 2, 3 }); goto negate; + swizzle_wzzw: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 2, 3 }); goto negate; + swizzle_xwzw: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 2, 3 }); goto negate; + swizzle_ywzw: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 2, 3 }); goto negate; + swizzle_zwzw: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 2, 3 }); goto negate; + swizzle_wwzw: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 2, 3 }); goto negate; + swizzle_xxww: vec = swizzle (vec, (pr_lvec4_t) { 0, 0, 3, 3 }); goto negate; + swizzle_yxww: vec = swizzle (vec, (pr_lvec4_t) { 1, 0, 3, 3 }); goto negate; + swizzle_zxww: vec = swizzle (vec, (pr_lvec4_t) { 2, 0, 3, 3 }); goto negate; + swizzle_wxww: vec = swizzle (vec, (pr_lvec4_t) { 3, 0, 3, 3 }); goto negate; + swizzle_xyww: vec = swizzle (vec, (pr_lvec4_t) { 0, 1, 3, 3 }); goto negate; + swizzle_yyww: vec = swizzle (vec, (pr_lvec4_t) { 1, 1, 3, 3 }); goto negate; + swizzle_zyww: vec = swizzle (vec, (pr_lvec4_t) { 2, 1, 3, 3 }); goto negate; + swizzle_wyww: vec = swizzle (vec, (pr_lvec4_t) { 3, 1, 3, 3 }); goto negate; + swizzle_xzww: vec = swizzle (vec, (pr_lvec4_t) { 0, 2, 3, 3 }); goto negate; + swizzle_yzww: vec = swizzle (vec, (pr_lvec4_t) { 1, 2, 3, 3 }); goto negate; + swizzle_zzww: vec = swizzle (vec, (pr_lvec4_t) { 2, 2, 3, 3 }); goto negate; + swizzle_wzww: vec = swizzle (vec, (pr_lvec4_t) { 3, 2, 3, 3 }); goto negate; + swizzle_xwww: vec = swizzle (vec, (pr_lvec4_t) { 0, 3, 3, 3 }); goto negate; + swizzle_ywww: vec = swizzle (vec, (pr_lvec4_t) { 1, 3, 3, 3 }); goto negate; + swizzle_zwww: vec = swizzle (vec, (pr_lvec4_t) { 2, 3, 3, 3 }); goto negate; + swizzle_wwww: vec = swizzle (vec, (pr_lvec4_t) { 3, 3, 3, 3 }); goto negate; + static void *swizzle_table[256] = { + &&swizzle_xxxx, &&swizzle_yxxx, &&swizzle_zxxx, &&swizzle_wxxx, + &&swizzle_xyxx, &&swizzle_yyxx, &&swizzle_zyxx, &&swizzle_wyxx, + &&swizzle_xzxx, &&swizzle_yzxx, &&swizzle_zzxx, &&swizzle_wzxx, + &&swizzle_xwxx, &&swizzle_ywxx, &&swizzle_zwxx, &&swizzle_wwxx, + &&swizzle_xxyx, &&swizzle_yxyx, &&swizzle_zxyx, &&swizzle_wxyx, + &&swizzle_xyyx, &&swizzle_yyyx, &&swizzle_zyyx, &&swizzle_wyyx, + &&swizzle_xzyx, &&swizzle_yzyx, &&swizzle_zzyx, &&swizzle_wzyx, + &&swizzle_xwyx, &&swizzle_ywyx, &&swizzle_zwyx, &&swizzle_wwyx, + &&swizzle_xxzx, &&swizzle_yxzx, &&swizzle_zxzx, &&swizzle_wxzx, + &&swizzle_xyzx, &&swizzle_yyzx, &&swizzle_zyzx, &&swizzle_wyzx, + &&swizzle_xzzx, &&swizzle_yzzx, &&swizzle_zzzx, &&swizzle_wzzx, + &&swizzle_xwzx, &&swizzle_ywzx, &&swizzle_zwzx, &&swizzle_wwzx, + &&swizzle_xxwx, &&swizzle_yxwx, &&swizzle_zxwx, &&swizzle_wxwx, + &&swizzle_xywx, &&swizzle_yywx, &&swizzle_zywx, &&swizzle_wywx, + &&swizzle_xzwx, &&swizzle_yzwx, &&swizzle_zzwx, &&swizzle_wzwx, + &&swizzle_xwwx, &&swizzle_ywwx, &&swizzle_zwwx, &&swizzle_wwwx, + &&swizzle_xxxy, &&swizzle_yxxy, &&swizzle_zxxy, &&swizzle_wxxy, + &&swizzle_xyxy, &&swizzle_yyxy, &&swizzle_zyxy, &&swizzle_wyxy, + &&swizzle_xzxy, &&swizzle_yzxy, &&swizzle_zzxy, &&swizzle_wzxy, + &&swizzle_xwxy, &&swizzle_ywxy, &&swizzle_zwxy, &&swizzle_wwxy, + &&swizzle_xxyy, &&swizzle_yxyy, &&swizzle_zxyy, &&swizzle_wxyy, + &&swizzle_xyyy, &&swizzle_yyyy, &&swizzle_zyyy, &&swizzle_wyyy, + &&swizzle_xzyy, &&swizzle_yzyy, &&swizzle_zzyy, &&swizzle_wzyy, + &&swizzle_xwyy, &&swizzle_ywyy, &&swizzle_zwyy, &&swizzle_wwyy, + &&swizzle_xxzy, &&swizzle_yxzy, &&swizzle_zxzy, &&swizzle_wxzy, + &&swizzle_xyzy, &&swizzle_yyzy, &&swizzle_zyzy, &&swizzle_wyzy, + &&swizzle_xzzy, &&swizzle_yzzy, &&swizzle_zzzy, &&swizzle_wzzy, + &&swizzle_xwzy, &&swizzle_ywzy, &&swizzle_zwzy, &&swizzle_wwzy, + &&swizzle_xxwy, &&swizzle_yxwy, &&swizzle_zxwy, &&swizzle_wxwy, + &&swizzle_xywy, &&swizzle_yywy, &&swizzle_zywy, &&swizzle_wywy, + &&swizzle_xzwy, &&swizzle_yzwy, &&swizzle_zzwy, &&swizzle_wzwy, + &&swizzle_xwwy, &&swizzle_ywwy, &&swizzle_zwwy, &&swizzle_wwwy, + &&swizzle_xxxz, &&swizzle_yxxz, &&swizzle_zxxz, &&swizzle_wxxz, + &&swizzle_xyxz, &&swizzle_yyxz, &&swizzle_zyxz, &&swizzle_wyxz, + &&swizzle_xzxz, &&swizzle_yzxz, &&swizzle_zzxz, &&swizzle_wzxz, + &&swizzle_xwxz, &&swizzle_ywxz, &&swizzle_zwxz, &&swizzle_wwxz, + &&swizzle_xxyz, &&swizzle_yxyz, &&swizzle_zxyz, &&swizzle_wxyz, + &&swizzle_xyyz, &&swizzle_yyyz, &&swizzle_zyyz, &&swizzle_wyyz, + &&swizzle_xzyz, &&swizzle_yzyz, &&swizzle_zzyz, &&swizzle_wzyz, + &&swizzle_xwyz, &&swizzle_ywyz, &&swizzle_zwyz, &&swizzle_wwyz, + &&swizzle_xxzz, &&swizzle_yxzz, &&swizzle_zxzz, &&swizzle_wxzz, + &&swizzle_xyzz, &&swizzle_yyzz, &&swizzle_zyzz, &&swizzle_wyzz, + &&swizzle_xzzz, &&swizzle_yzzz, &&swizzle_zzzz, &&swizzle_wzzz, + &&swizzle_xwzz, &&swizzle_ywzz, &&swizzle_zwzz, &&swizzle_wwzz, + &&swizzle_xxwz, &&swizzle_yxwz, &&swizzle_zxwz, &&swizzle_wxwz, + &&swizzle_xywz, &&swizzle_yywz, &&swizzle_zywz, &&swizzle_wywz, + &&swizzle_xzwz, &&swizzle_yzwz, &&swizzle_zzwz, &&swizzle_wzwz, + &&swizzle_xwwz, &&swizzle_ywwz, &&swizzle_zwwz, &&swizzle_wwwz, + &&swizzle_xxxw, &&swizzle_yxxw, &&swizzle_zxxw, &&swizzle_wxxw, + &&swizzle_xyxw, &&swizzle_yyxw, &&swizzle_zyxw, &&swizzle_wyxw, + &&swizzle_xzxw, &&swizzle_yzxw, &&swizzle_zzxw, &&swizzle_wzxw, + &&swizzle_xwxw, &&swizzle_ywxw, &&swizzle_zwxw, &&swizzle_wwxw, + &&swizzle_xxyw, &&swizzle_yxyw, &&swizzle_zxyw, &&swizzle_wxyw, + &&swizzle_xyyw, &&swizzle_yyyw, &&swizzle_zyyw, &&swizzle_wyyw, + &&swizzle_xzyw, &&swizzle_yzyw, &&swizzle_zzyw, &&swizzle_wzyw, + &&swizzle_xwyw, &&swizzle_ywyw, &&swizzle_zwyw, &&swizzle_wwyw, + &&swizzle_xxzw, &&swizzle_yxzw, &&swizzle_zxzw, &&swizzle_wxzw, + &&swizzle_xyzw, &&swizzle_yyzw, &&swizzle_zyzw, &&swizzle_wyzw, + &&swizzle_xzzw, &&swizzle_yzzw, &&swizzle_zzzw, &&swizzle_wzzw, + &&swizzle_xwzw, &&swizzle_ywzw, &&swizzle_zwzw, &&swizzle_wwzw, + &&swizzle_xxww, &&swizzle_yxww, &&swizzle_zxww, &&swizzle_wxww, + &&swizzle_xyww, &&swizzle_yyww, &&swizzle_zyww, &&swizzle_wyww, + &&swizzle_xzww, &&swizzle_yzww, &&swizzle_zzww, &&swizzle_wzww, + &&swizzle_xwww, &&swizzle_ywww, &&swizzle_zwww, &&swizzle_wwww, + }; +#undef swizzle + static const pr_lvec4_t neg[16] = { + { 0l, 0l, 0l, 0l }, + { 1l<<63, 0l, 0l, 0l }, + { 0l, 1l<<63, 0l, 0l }, + { 1l<<63, 1l<<63, 0l, 0l }, + { 0l, 0l, 1l<<63, 0l }, + { 1l<<63, 0l, 1l<<63, 0l }, + { 0l, 1l<<63, 1l<<63, 0l }, + { 1l<<63, 1l<<63, 1l<<63, 0l }, + { 0l, 0l, 0l, 1l<<63 }, + { 1l<<63, 0l, 0l, 1l<<63 }, + { 0l, 1l<<63, 0l, 1l<<63 }, + { 1l<<63, 1l<<63, 0l, 1l<<63 }, + { 0l, 0l, 1l<<63, 1l<<63 }, + { 1l<<63, 0l, 1l<<63, 1l<<63 }, + { 0l, 1l<<63, 1l<<63, 1l<<63 }, + { 1l<<63, 1l<<63, 1l<<63, 1l<<63 }, + }; + static const pr_lvec4_t zero[16] = { + { ~0l, ~0l, ~0l, ~0l }, + { 0l, ~0l, ~0l, ~0l }, + { ~0l, 0l, ~0l, ~0l }, + { 0l, 0l, ~0l, ~0l }, + { ~0l, ~0l, 0l, ~0l }, + { 0l, ~0l, 0l, ~0l }, + { ~0l, 0l, 0l, ~0l }, + { 0l, 0l, 0l, ~0l }, + { ~0l, ~0l, ~0l, 0l }, + { 0l, ~0l, ~0l, 0l }, + { ~0l, 0l, ~0l, 0l }, + { 0l, 0l, ~0l, 0l }, + { ~0l, ~0l, 0l, 0l }, + { 0l, ~0l, 0l, 0l }, + { ~0l, 0l, 0l, 0l }, + { 0l, 0l, 0l, 0l }, + }; + +do_swizzle: + goto *swizzle_table[swiz & 0xff]; +negate: + vec ^= neg[(swiz >> 8) & 0xf]; + vec &= zero[(swiz >> 12) & 0xf]; + return vec; +} + static void pr_exec_ruamoko (progs_t *pr, int exitdepth) { @@ -2994,6 +3367,9 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) break; //FIXME misc ops OP_op_T (LE, U, ulong, ulvec2, ulvec4, <=); + case OP_SWIZZLE_D: + OPC(lvec4) = pr_swizzle_d (OPA(lvec4), st->b); + break; //FIXME misc ops // 1 1111 //FIXME conversion 3 From 6de1ba690131c0f351f6a821912b445e038c6956 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 22:54:34 +0900 Subject: [PATCH 028/360] [gamecode] Clean up the conversion instructions Float bit-ops as well. Also, add q*v4 and v4*q instructions. There are currently 48 free opcodes, and I might remove the scale instructions, but they could be useful as expanding a single float to a vector would take 3 instructions (copy to temp, swizzle-expand temp, multiply, vs just scale). --- include/QF/pr_comp.h | 60 +++++++++++++++++++++-------------------- libs/gamecode/pr_exec.c | 35 +++++++++++++++--------- 2 files changed, 53 insertions(+), 42 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index 541c69978..d72ced1ca 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -484,11 +484,11 @@ typedef enum { OP_GT_F_1, OP_GT_F_2, OP_GT_F_3, OP_GT_F_4, OP_GT_L_1, OP_GT_L_2, OP_GT_L_3, OP_GT_L_4, OP_GT_D_1, OP_GT_D_2, OP_GT_D_3, OP_GT_D_4, - // 0 1011 convert between signed integral and double(XXX how useful as vec?) - OP_CONV_ID_1, OP_CONV_ID_2, OP_CONV_ID_3, OP_CONV_ID_4, - OP_CONV_DI_1, OP_CONV_DI_2, OP_CONV_DI_3, OP_CONV_DI_4, - OP_CONV_LD_1, OP_CONV_LD_2, OP_CONV_LD_3, OP_CONV_LD_4, - OP_CONV_DL_1, OP_CONV_DL_2, OP_CONV_DL_3, OP_CONV_DL_4, + // 0 1011 + OP_spare_1, OP_spare_2, OP_spare_3, OP_spare_4, + OP_spare_5, OP_spare_6, OP_spare_7, OP_spare_8, + OP_spare_9, OP_spare_10, OP_spare_11, OP_spare_12, + OP_spare_13, OP_spare_14, OP_spare_15, OP_spare_16, // comparison // 0 1100 != OP_NE_I_1, OP_NE_I_2, OP_NE_I_3, OP_NE_I_4, @@ -505,11 +505,11 @@ typedef enum { OP_LE_F_1, OP_LE_F_2, OP_LE_F_3, OP_LE_F_4, OP_LE_L_1, OP_LE_L_2, OP_LE_L_3, OP_LE_L_4, OP_LE_D_1, OP_LE_D_2, OP_LE_D_3, OP_LE_D_4, - // 0 1111 convert between signed integral sizes (XXX how useful as vec?) - OP_CONV_IL_1, OP_CONV_IL_2, OP_CONV_IL_3, OP_CONV_IL_4, - OP_CONV_LI_1, OP_CONV_LI_2, OP_CONV_LI_3, OP_CONV_LI_4, - OP_CONV_uU_1, OP_CONV_uU_2, OP_CONV_uU_3, OP_CONV_uU_4, - OP_CONV_Uu_1, OP_CONV_Uu_2, OP_CONV_Uu_3, OP_CONV_Uu_4, + // 0 1111 + OP_spare_17, OP_spare_18, OP_spare_19, OP_spare_20, + OP_spare_21, OP_spare_22, OP_spare_23, OP_spare_24, + OP_spare_25, OP_spare_26, OP_spare_27, OP_spare_28, + OP_spare_29, OP_spare_30, OP_spare_31, OP_spare_32, // 1 0000 c = a * b OP_MUL_I_1, OP_MUL_I_2, OP_MUL_I_3, OP_MUL_I_4, @@ -556,16 +556,16 @@ typedef enum { OP_BITOR_I_1, OP_BITOR_I_2, OP_BITOR_I_3, OP_BITOR_I_4, OP_BITXOR_I_1, OP_BITXOR_I_2, OP_BITXOR_I_3, OP_BITXOR_I_4, OP_BITNOT_I_1, OP_BITNOT_I_2, OP_BITNOT_I_3, OP_BITNOT_I_4, - // 1 1001 < unsigned (float logic and bit ops mixed in) + // 1 1001 < unsigned with swizzle and scale mixed in OP_LT_u_1, OP_LT_u_2, OP_LT_u_3, OP_LT_u_4, - OP_BITAND_F, OP_BITOR_F, OP_BITXOR_F, OP_BITNOT_F, + OP_SWIZZLE_F, OP_SCALE_F_2, OP_SCALE_F_3, OP_SCALE_F_4, OP_LT_U_1, OP_LT_U_2, OP_LT_U_3, OP_LT_U_4, - OP_AND_F, OP_OR_F, OP_XOR_F, OP_NOT_F, - // 1 1010 > unsigned + OP_SWIZZLE_D, OP_SCALE_D_2, OP_SCALE_D_3, OP_SCALE_D_4, + // 1 1010 > unsigned and conversions OP_GT_u_1, OP_GT_u_2, OP_GT_u_3, OP_GT_u_4, - OP_spare, OP_NOT_D, OP_NOT_V, OP_NOT_Q, + OP_CONV_IF_1, OP_CONV_LD_1, OP_CONV_uF_1, OP_CONV_UD_1, OP_GT_U_1, OP_GT_U_2, OP_GT_U_3, OP_GT_U_4, - OP_EQ_V, OP_EQ_Q, OP_NE_V, OP_NE_Q, + OP_CONV_FI_1, OP_CONV_DL_1, OP_CONV_Fu_1, OP_CONV_DU_1, // 1 1011 lea, with, etc OP_LEA_A, OP_LEA_B, OP_LEA_C, OP_LEA_D, OP_LEA_E, OP_ANY_2, OP_ANY_3, OP_ANY_4, @@ -576,21 +576,23 @@ typedef enum { OP_OR_I_1, OP_OR_I_2, OP_OR_I_3, OP_OR_I_4, OP_XOR_I_1, OP_XOR_I_2, OP_XOR_I_3, OP_XOR_I_4, OP_NOT_I_1, OP_NOT_I_2, OP_NOT_I_3, OP_NOT_I_4, - // 1 1101 >= unsigned with float shifts and moves mixed in - OP_GE_u_1, OP_GE_u_2, OP_GE_u_3, OP_GE_u_4, - OP_SHL_F, OP_MOVE_I, OP_MOVE_P, OP_MOVE_PI, - OP_GE_U_1, OP_GE_U_2, OP_GE_U_3, OP_GE_U_4, - OP_SHR_F, OP_MEMSET_I, OP_MEMSET_P, OP_MEMSET_PI, - // 1 1110 <= unsigned with scale and swizzle mixed in + // 1 1101 >= unsigned with q v4 mul and moves mixed in + OP_GE_u_1, OP_GE_u_2, OP_GE_u_3, OP_GE_u_4, + OP_MUL_QV4_F, OP_MOVE_I, OP_MOVE_P, OP_MOVE_PI, + OP_GE_U_1, OP_GE_U_2, OP_GE_U_3, OP_GE_U_4, + OP_MUL_QV4_D, OP_MEMSET_I, OP_MEMSET_P, OP_MEMSET_PI, + // 1 1110 <= unsigned with v4 q mul and conversion mixed in OP_LE_u_1, OP_LE_u_2, OP_LE_u_3, OP_LE_u_4, - OP_SWIZZLE_F, OP_SCALE_F_2, OP_SCALE_F_3, OP_SCALE_F_4, + OP_MUL_V4Q_F, OP_CONV_IL_1, OP_CONV_uU_1, OP_CONV_FD_1, OP_LE_U_1, OP_LE_U_2, OP_LE_U_3, OP_LE_U_4, - OP_SWIZZLE_D, OP_SCALE_D_2, OP_SCALE_D_3, OP_SCALE_D_4, - // 1 1111 convert between integral and float (XXX how useful as vec?) - OP_CONV_IF_1, OP_CONV_IF_2, OP_CONV_IF_3, OP_CONV_IF_4, - OP_CONV_FI_1, OP_CONV_FI_2, OP_CONV_FI_3, OP_CONV_FI_4, - OP_CONV_FD_1, OP_CONV_FD_2, OP_CONV_FD_3, OP_CONV_FD_4, - OP_CONV_DF_1, OP_CONV_DF_2, OP_CONV_DF_3, OP_CONV_DF_4, + OP_MUL_V4Q_D, OP_CONV_LI_1, OP_CONV_Uu_1, OP_CONV_DF_1, + // 1 1111 + OP_spare_33, OP_spare_34, OP_spare_35, OP_spare_36, + OP_spare_37, OP_spare_38, OP_spare_39, OP_spare_40, + OP_spare_41, OP_spare_42, OP_spare_43, OP_spare_44, + OP_spare_45, OP_spare_46, OP_spare_47, OP_spare_48, + + } pr_opcode_e; #define OP_A_SHIFT (9) #define OP_B_SHIFT (11) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 1f8541ed8..9fdb6853e 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -3228,14 +3228,20 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OP_uop_T (BITNOT, I, int, ivec2, ivec4, ~); // 1 1001 OP_op_T (LT, u, uint, uivec2, uivec4, <); - //FIXME float ops + case OP_SWIZZLE_F: + OPC(ivec4) = pr_swizzle_f (OPA(ivec4), st->b); + break; + //FIXME scale ops OP_op_T (LT, U, ulong, ulvec2, ulvec4, <); - //FIXME float ops + case OP_SWIZZLE_D: + OPC(lvec4) = pr_swizzle_d (OPA(lvec4), st->b); + break; + //FIXME scale ops // 1 1010 OP_op_T (GT, u, uint, uivec2, uivec4, >); - //FIXME misc ops + //FIXME conversion ops OP_op_T (GT, U, ulong, ulvec2, ulvec4, >); - //FIXME misc ops + //FIXME conversion ops // 1 1011 case OP_LEA_A: case OP_LEA_B: @@ -3337,7 +3343,9 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OP_not_n (NOT, ivec4, 4, +); // 1 1101 OP_op_T (GE, u, uint, uivec2, uivec4, >=); - //FIXME float shift + case OP_MUL_QV4_F: + OPC(vec4) = qvmulf (OPA(vec4), OPB(vec4)); + break; case OP_MOVE_I: memmove (op_c, op_a, st->b * sizeof (pr_type_t)); break; @@ -3350,7 +3358,9 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) st->b * sizeof (pr_type_t)); break; OP_op_T (GE, U, ulong, ulvec2, ulvec4, >=); - //FIXME float shift + case OP_MUL_QV4_D: + OPC(dvec4) = qvmuld (OPA(dvec4), OPB(dvec4)); + break; case OP_MEMSET_I: pr_memset (op_c, OPA(int), st->b); break; @@ -3362,17 +3372,16 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) break; // 1 1110 OP_op_T (LE, u, uint, uivec2, uivec4, <=); - case OP_SWIZZLE_F: - OPC(ivec4) = pr_swizzle_f (OPA(ivec4), st->b); + case OP_MUL_V4Q_F: + OPC(vec4) = vqmulf (OPA(vec4), OPB(vec4)); break; - //FIXME misc ops + OP_op_T (LE, U, ulong, ulvec2, ulvec4, <=); - case OP_SWIZZLE_D: - OPC(lvec4) = pr_swizzle_d (OPA(lvec4), st->b); + case OP_MUL_V4Q_D: + OPC(dvec4) = vqmuld (OPA(dvec4), OPB(dvec4)); break; - //FIXME misc ops + // 1 1111 - //FIXME conversion 3 default: PR_RunError (pr, "Bad opcode o%03o", st->op & OP_MASK); From 09b029d82ca1118a5637f8f723491048ebdb6bb6 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 23:00:22 +0900 Subject: [PATCH 029/360] [simd] Correct result for cmuld I must have had quite the brain-fart when I wrote that. Yay for tests :) --- include/QF/simd/vec2d.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/include/QF/simd/vec2d.h b/include/QF/simd/vec2d.h index 6b50ea6b4..206e7f18b 100644 --- a/include/QF/simd/vec2d.h +++ b/include/QF/simd/vec2d.h @@ -107,9 +107,9 @@ VISIBLE vec2d_t cmuld (vec2d_t a, vec2d_t b) { - vec2d_t c = a * b[0]; - c = _mm_addsub_pd (c, (vec2d_t) { c[1], c[0] }); - return c; + vec2d_t c1 = a * b[0]; + vec2d_t c2 = a * b[1]; + return _mm_addsub_pd (c1, (vec2d_t) { c2[1], c2[0] }); } #endif//__QF_simd_vec2d_h From a6badaa05d017a980d6a2682cce7dc90110aa8e6 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 23:01:47 +0900 Subject: [PATCH 030/360] [gamecode] Complete the vector instruction tests Finish up the float tests and add double tests. --- libs/gamecode/test/test-math.c | 111 ++++++++++++++++++++++++++++++--- 1 file changed, 102 insertions(+), 9 deletions(-) diff --git a/libs/gamecode/test/test-math.c b/libs/gamecode/test/test-math.c index b5daab225..61d8852e9 100644 --- a/libs/gamecode/test/test-math.c +++ b/libs/gamecode/test/test-math.c @@ -5,18 +5,24 @@ static pr_vec4_t float_globals_init[] = { {0, 0, 0, 0}, {1, 2, 3, 8}, {4, 5, 6, 8}, + {0, 0, 0, 7}, {0, 0, 0, 7}, {1, 2, 3, 4}, {5, 6, 7, 8}, + {2, 3, 4, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 7}, + {0, 0, 0, 7}, {0, 0, 0, 7}, {0, 0, 0, 7}, {0, 0, 0, 0}, + + {0, 0, 0, 0}, + {0, 0, 0, 0}, {0, 0, 0, 0}, }; @@ -37,14 +43,16 @@ static pr_vec4_t float_globals_expect[] = { {36, 102, 120, 7}, {52, 70, 136, 7}, - {160, 160, 160, 160}, - {9, 10, 17, 20}, + {36, 102, 120, 0}, + {52, 70, 136, 0}, {-1, -2, -3, 4}, {-1, -2, -3, 4}, + {36, 102, 120, 0}, + {52, 70, 136, 0}, }; -static dstatement_t store_A_statements[] = { +static dstatement_t float_vector_statements[] = { { OP(0, 0, 0, OP_DOT_CC_F), 0, 2, 4 }, { OP(0, 0, 0, OP_MUL_CC_F), 0, 2, 6 }, { OP(0, 0, 0, OP_DOT_VV_F), 8, 12, 16 }, @@ -54,24 +62,109 @@ static dstatement_t store_A_statements[] = { { OP(0, 0, 0, OP_MUL_QV_F), 24, 32, 44 }, { OP(0, 0, 0, OP_MUL_VQ_F), 32, 24, 48 }, - { OP(0, 0, 0, OP_DOT_QQ_F), 24, 32, 52 }, + { OP(0, 0, 0, OP_MUL_QQ_F), 24, 32, 52 }, { OP(0, 0, 0, OP_SWIZZLE_F), 24, 0x07e4, 60 }, - { OP(0, 0, 0, OP_DOT_QQ_F), 52, 60, 52 }, + { OP(0, 0, 0, OP_MUL_QQ_F), 52, 60, 52 }, { OP(0, 0, 0, OP_SWIZZLE_F), 24, 0x07e4, 64 }, - { OP(0, 0, 0, OP_MUL_QQ_F), 60, 32, 56 }, - { OP(0, 0, 0, OP_DOT_QQ_F), 56, 24, 52 }, + { OP(0, 0, 0, OP_MUL_QQ_F), 64, 32, 56 }, + { OP(0, 0, 0, OP_MUL_QQ_F), 56, 24, 56 }, + + { OP(0, 0, 0, OP_MUL_QV4_F), 24, 32, 68 }, + { OP(0, 0, 0, OP_MUL_V4Q_F), 32, 24, 72 }, +}; + +static pr_dvec4_t double_globals_init[] = { + {3, 4, 5, 12}, + {0, 0, 0, 0}, + {1, 2, 3, 8}, + {4, 5, 6, 8}, + + {0, 0, 0, 7}, + {0, 0, 0, 7}, + {1, 2, 3, 4}, + {5, 6, 7, 8}, + + {2, 3, 4, 0}, + {0, 0, 0, 0}, + {0, 0, 0, 0}, + {0, 0, 0, 7}, + + {0, 0, 0, 7}, + {0, 0, 0, 7}, + {0, 0, 0, 7}, + {0, 0, 0, 0}, + + {0, 0, 0, 0}, + {0, 0, 0, 0}, + {0, 0, 0, 0}, +}; + +static pr_dvec4_t double_globals_expect[] = { + {3, 4, 5, 12}, + {63, 63, -33, 56}, + {1, 2, 3, 8}, + {4, 5, 6, 8}, + + {32, 32, 32, 7}, + {-3, 6, -3, 7}, + {1, 2, 3, 4}, + {5, 6, 7, 8}, + + {2, 3, 4, 0}, + {70, 70, 70, 70}, + {24, 48, 48, -6}, + {36, 102, 120, 7}, + + {52, 70, 136, 7}, + {36, 102, 120, 0}, + {52, 70, 136, 0}, + {-1, -2, -3, 4}, + + {-1, -2, -3, 4}, + {36, 102, 120, 0}, + {52, 70, 136, 0}, +}; + +static dstatement_t double_vector_statements[] = { + { OP(0, 0, 0, OP_DOT_CC_D), 0, 4, 8 }, + { OP(0, 0, 0, OP_MUL_CC_D), 0, 4, 12 }, + { OP(0, 0, 0, OP_DOT_VV_D), 16, 24, 32 }, + { OP(0, 0, 0, OP_CROSS_VV_D), 16, 24, 40 }, + { OP(0, 0, 0, OP_DOT_QQ_D), 48, 56, 72 }, + { OP(0, 0, 0, OP_MUL_QQ_D), 48, 56, 80 }, + { OP(0, 0, 0, OP_MUL_QV_D), 48, 64, 88 }, + { OP(0, 0, 0, OP_MUL_VQ_D), 64, 48, 96 }, + + { OP(0, 0, 0, OP_MUL_QQ_D), 48, 64, 104 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 48, 0x07e4, 120 }, + { OP(0, 0, 0, OP_MUL_QQ_D), 104, 120, 104 }, + + { OP(0, 0, 0, OP_SWIZZLE_D), 48, 0x07e4, 128 }, + { OP(0, 0, 0, OP_MUL_QQ_D), 128, 64, 112 }, + { OP(0, 0, 0, OP_MUL_QQ_D), 112, 48, 112 }, + + { OP(0, 0, 0, OP_MUL_QV4_D), 48, 64, 136 }, + { OP(0, 0, 0, OP_MUL_V4Q_D), 64, 48, 144 }, }; test_t tests[] = { { .desc = "float vector", .num_globals = 4*num_globals(float_globals_init, float_globals_expect), - .num_statements = num_statements (store_A_statements), - .statements = store_A_statements, + .num_statements = num_statements (float_vector_statements), + .statements = float_vector_statements, .init_globals = (pr_int_t *) float_globals_init, .expect_globals = (pr_int_t *) float_globals_expect, }, + { + .desc = "double vector", + .num_globals = 8*num_globals(double_globals_init,double_globals_expect), + .num_statements = num_statements (double_vector_statements), + .statements = double_vector_statements, + .init_globals = (pr_int_t *) double_globals_init, + .expect_globals = (pr_int_t *) double_globals_expect, + }, }; #include "main.c" From 4777f44ba1558a0b0c0024876e60e54c5c4ccccb Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 3 Jan 2022 23:50:38 +0900 Subject: [PATCH 031/360] [gamecode] Rename test-math to test-vector I decided to stick with the minimal tests per test program rather than try to cram all the math operator tests into the one program. --- libs/gamecode/test/Makemodule.am | 12 ++++++------ libs/gamecode/test/{test-math.c => test-vector.c} | 0 2 files changed, 6 insertions(+), 6 deletions(-) rename libs/gamecode/test/{test-math.c => test-vector.c} (100%) diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index 433fad58f..191470c74 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -1,6 +1,6 @@ libs_gamecode_tests = \ libs/gamecode/test/test-load \ - libs/gamecode/test/test-math \ + libs/gamecode/test/test-vector \ libs/gamecode/test/test-stack \ libs/gamecode/test/test-store @@ -19,11 +19,6 @@ libs_gamecode_test_test_load_SOURCES= \ libs_gamecode_test_test_load_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_load_DEPENDENCIES= $(test_gamecode_libs) -libs_gamecode_test_test_math_SOURCES= \ - libs/gamecode/test/test-math.c -libs_gamecode_test_test_math_LDADD= $(test_gamecode_libs) -libs_gamecode_test_test_math_DEPENDENCIES= $(test_gamecode_libs) - libs_gamecode_test_test_stack_SOURCES= \ libs/gamecode/test/test-stack.c libs_gamecode_test_test_stack_LDADD= $(test_gamecode_libs) @@ -33,3 +28,8 @@ libs_gamecode_test_test_store_SOURCES= \ libs/gamecode/test/test-store.c libs_gamecode_test_test_store_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_store_DEPENDENCIES= $(test_gamecode_libs) + +libs_gamecode_test_test_vector_SOURCES= \ + libs/gamecode/test/test-vector.c +libs_gamecode_test_test_vector_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_vector_DEPENDENCIES= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-math.c b/libs/gamecode/test/test-vector.c similarity index 100% rename from libs/gamecode/test/test-math.c rename to libs/gamecode/test/test-vector.c From 5de4c21557a8372828c27b5443febfabc25566b3 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 4 Jan 2022 14:30:20 +0900 Subject: [PATCH 032/360] [gamecode] Fix relative offset jumps Yet another missed sign extension. --- libs/gamecode/pr_exec.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 9fdb6853e..764b844ce 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1804,7 +1804,7 @@ pr_jump_mode (progs_t *pr, const dstatement_t *st) switch (jump_ind) { case 0: // instruction relative offset - jump_offs = jump_offs + st->a; + jump_offs = jump_offs + (short) st->a; break; case 1: // simple pointer dereference: *a From 9d74fcc181320ef98dc3e218fbd7da4c6ed04d0d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 4 Jan 2022 17:50:49 +0900 Subject: [PATCH 033/360] [gamecode] Add tests for the basic math ops * / % %% + - As a bonus, includes partial tests for a few extra operators. Several things are broken at this stage, but uncommitted code is already working. --- libs/gamecode/test/Makemodule.am | 24 ++++ libs/gamecode/test/main.c | 9 +- libs/gamecode/test/test-double.c | 192 +++++++++++++++++++++++++++++++ libs/gamecode/test/test-float.c | 192 +++++++++++++++++++++++++++++++ libs/gamecode/test/test-int.c | 146 +++++++++++++++++++++++ libs/gamecode/test/test-long.c | 148 ++++++++++++++++++++++++ 6 files changed, 709 insertions(+), 2 deletions(-) create mode 100644 libs/gamecode/test/test-double.c create mode 100644 libs/gamecode/test/test-float.c create mode 100644 libs/gamecode/test/test-int.c create mode 100644 libs/gamecode/test/test-long.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index 191470c74..2df9ef114 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -1,5 +1,9 @@ libs_gamecode_tests = \ + libs/gamecode/test/test-double \ + libs/gamecode/test/test-float \ + libs/gamecode/test/test-int \ libs/gamecode/test/test-load \ + libs/gamecode/test/test-long \ libs/gamecode/test/test-vector \ libs/gamecode/test/test-stack \ libs/gamecode/test/test-store @@ -14,11 +18,31 @@ test_gamecode_libs= \ libs/gamecode/libQFgamecode.la \ libs/util/libQFutil.la +libs_gamecode_test_test_double_SOURCES= \ + libs/gamecode/test/test-double.c +libs_gamecode_test_test_double_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_double_DEPENDENCIES= $(test_gamecode_libs) + +libs_gamecode_test_test_float_SOURCES= \ + libs/gamecode/test/test-float.c +libs_gamecode_test_test_float_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_float_DEPENDENCIES= $(test_gamecode_libs) + +libs_gamecode_test_test_int_SOURCES= \ + libs/gamecode/test/test-int.c +libs_gamecode_test_test_int_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_int_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_load_SOURCES= \ libs/gamecode/test/test-load.c libs_gamecode_test_test_load_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_load_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_long_SOURCES= \ + libs/gamecode/test/test-long.c +libs_gamecode_test_test_long_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_long_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_stack_SOURCES= \ libs/gamecode/test/test-stack.c libs_gamecode_test_test_stack_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/main.c b/libs/gamecode/test/main.c index e9256dcec..44e91167e 100644 --- a/libs/gamecode/test/main.c +++ b/libs/gamecode/test/main.c @@ -84,7 +84,7 @@ setup_test (test_t *test) num_globals += test->extra_globals + test->stack_size; test_pr.globals_size = num_globals; - test_pr.pr_globals = malloc (num_globals * sizeof (pr_type_t)); + test_pr.pr_globals = Sys_Alloc (num_globals * sizeof (pr_type_t)); memcpy (test_pr.pr_globals, test->init_globals, test->num_globals * sizeof (pr_type_t)); memset (test_pr.pr_globals + test->num_globals, 0, @@ -99,6 +99,7 @@ setup_test (test_t *test) test_pr.pr_edict_area = test_pr.pr_globals + test->edict_area; } + test_progs.numstatements = test->num_statements + 1; test_pr.pr_statements = malloc ((test->num_statements + 1) * sizeof (dstatement_t)); memcpy (test_pr.pr_statements, test->statements, @@ -139,7 +140,11 @@ run_test (test_t *test) } else { printf ("test #%zd: %s: critical failure\n", test - tests, test->desc); } - free (test_pr.pr_globals); + + pr_uint_t num_globals = test->num_globals; + num_globals += test->extra_globals + test->stack_size; + Sys_Free (test_pr.pr_globals, num_globals * sizeof (pr_type_t)); + free (test_pr.pr_statements); return ret; } diff --git a/libs/gamecode/test/test-double.c b/libs/gamecode/test/test-double.c new file mode 100644 index 000000000..230ba69ee --- /dev/null +++ b/libs/gamecode/test/test-double.c @@ -0,0 +1,192 @@ +#include "head.c" + +#include "QF/mathlib.h" + +#define sq(x) ((x)*(x)) + +static pr_dvec4_t double_binop_init[] = { + { 5, -5, 5, -5}, + { 3, 3, -3, -3}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_dvec4_t double_binop_expect[] = { + { 5, -5, 5, -5}, + { 3, 3, -3, -3}, + { 15, -15, -15, 15}, + { 5.0/3, -5.0/3, -5.0/3, 5.0/3}, + { 2, -2, 2, -2}, + { 2, 1, -1, -2}, + { 8, -2, 2, -8}, + { 2, -8, 8, -2}, +}; + +static dstatement_t double_binop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 64, -2, 64 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, + { OP(1, 1, 1, OP_MUL_D_1), 0, 8, 16 }, + { OP(1, 1, 1, OP_DIV_D_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_REM_D_1), 0, 8, 32 }, + { OP(1, 1, 1, OP_MOD_D_1), 0, 8, 40 }, + { OP(1, 1, 1, OP_ADD_D_1), 0, 8, 48 }, + { OP(1, 1, 1, OP_SUB_D_1), 0, 8, 56 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t double_binop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 64, -4, 64 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, + { OP(1, 1, 1, OP_MUL_D_2), 0, 8, 16 }, + { OP(1, 1, 1, OP_DIV_D_2), 0, 8, 24 }, + { OP(1, 1, 1, OP_REM_D_2), 0, 8, 32 }, + { OP(1, 1, 1, OP_MOD_D_2), 0, 8, 40 }, + { OP(1, 1, 1, OP_ADD_D_2), 0, 8, 48 }, + { OP(1, 1, 1, OP_SUB_D_2), 0, 8, 56 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t double_binop_3a_statements[] = { + { OP(1, 1, 1, OP_MUL_D_3), 0, 8, 16 }, + { OP(1, 1, 1, OP_MUL_D_1), 6, 14, 22 }, + { OP(1, 1, 1, OP_DIV_D_3), 0, 8, 24 }, + { OP(1, 1, 1, OP_DIV_D_1), 6, 14, 30 }, + { OP(1, 1, 1, OP_REM_D_3), 0, 8, 32 }, + { OP(1, 1, 1, OP_REM_D_1), 6, 14, 38 }, + { OP(1, 1, 1, OP_MOD_D_3), 0, 8, 40 }, + { OP(1, 1, 1, OP_MOD_D_1), 6, 14, 46 }, + { OP(1, 1, 1, OP_ADD_D_3), 0, 8, 48 }, + { OP(1, 1, 1, OP_ADD_D_1), 6, 14, 54 }, + { OP(1, 1, 1, OP_SUB_D_3), 0, 8, 56 }, + { OP(1, 1, 1, OP_SUB_D_1), 6, 14, 62 }, +}; + +static dstatement_t double_binop_3b_statements[] = { + { OP(1, 1, 1, OP_MUL_D_1), 0, 8, 16 }, + { OP(1, 1, 1, OP_MUL_D_3), 2, 10, 18 }, + { OP(1, 1, 1, OP_DIV_D_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_DIV_D_3), 2, 10, 26 }, + { OP(1, 1, 1, OP_REM_D_1), 0, 8, 32 }, + { OP(1, 1, 1, OP_REM_D_3), 2, 10, 34 }, + { OP(1, 1, 1, OP_MOD_D_1), 0, 8, 40 }, + { OP(1, 1, 1, OP_MOD_D_3), 2, 10, 42 }, + { OP(1, 1, 1, OP_ADD_D_1), 0, 8, 48 }, + { OP(1, 1, 1, OP_ADD_D_3), 2, 10, 50 }, + { OP(1, 1, 1, OP_SUB_D_1), 0, 8, 56 }, + { OP(1, 1, 1, OP_SUB_D_3), 2, 10, 58 }, +}; + +static dstatement_t double_binop_4_statements[] = { + { OP(1, 1, 1, OP_MUL_D_4), 0, 8, 16 }, + { OP(1, 1, 1, OP_DIV_D_4), 0, 8, 24 }, + { OP(1, 1, 1, OP_REM_D_4), 0, 8, 32 }, + { OP(1, 1, 1, OP_MOD_D_4), 0, 8, 40 }, + { OP(1, 1, 1, OP_ADD_D_4), 0, 8, 48 }, + { OP(1, 1, 1, OP_SUB_D_4), 0, 8, 56 }, +}; + +static pr_dvec4_t double_cossin_init[] = { + { 1, 2, 3, 4 }, // 0: output + { M_PI/6, 0, 0, 0 }, // 4: x + { 1, 2, 0, 0 }, // 8: f + { 1, 1, 0, 25 }, // 12: f inc and f0 max + { 0, 0, 0, 0 }, // 16: x2 -> [xx, xx] + // { } // 20: xn +}; + +static pr_dvec4_t double_cossin_expect[] = { + { 0.8660254037844386, 0.49999999999999994, 0, 0 }, // 0: output + { M_PI/6, 0, 0, 0 }, // 4: x + { 25, 26, 0, 0 }, // 8: f + { 1, 1, 0, 25 }, // 12: f inc and f0 max + { -sq(M_PI/6), -sq(M_PI/6), 0, 0 }, // 16: x2 -> [xx, xx] +}; + +static dstatement_t double_cossin_statements[] = { + { OP(0, 0, 0, OP_STORE_A_2), 42, 0, 8 }, // init xn -> [?, x] + { OP(0, 0, 0, OP_STORE_A_2), 40, 0, 16 }, // init xn -> [1, x] + { OP(0, 0, 0, OP_SWIZZLE_D), 8,0xc000, 32 }, // init x2 -> [x, x, 0, 0] + { OP(0, 0, 0, OP_MUL_D_2), 32, 32, 32 }, // x2 -> [x*x, x*x, 0, 0] + { OP(0, 0, 0, OP_SWIZZLE_D), 32,0xc3e4, 32 }, // init x2 -> -x2 + { OP(0, 0, 0, OP_SUB_D_4), 0, 0, 0 }, // init acc (output) to 0 +// loop: + { OP(0, 0, 0, OP_ADD_D_2), 0, 40, 0 }, // acc += xn + { OP(0, 0, 0, OP_MUL_D_2), 40, 32, 40 }, // xn *= x2 + { OP(0, 0, 0, OP_DIV_D_2), 40, 16, 40 }, // xn /= f + { OP(0, 0, 0, OP_ADD_D_2), 16, 24, 16 }, // f += inc + { OP(0, 0, 0, OP_DIV_D_2), 40, 16, 40 }, // xn /= f + { OP(0, 0, 0, OP_ADD_D_2), 16, 24, 16 }, // f += inc + { OP(0, 0, 0, OP_LT_D_1), 16, 30, 46 }, // f0 < fmax + { OP(0, 0, 0, OP_IF_A), -7, 0, 46 }, // f0 < fmax +}; + +test_t tests[] = { + { + .desc = "double binop 1", + .extra_globals = 8 * 1, + .num_globals = 8*num_globals(double_binop_init,double_binop_expect), + .num_statements = num_statements (double_binop_1_statements), + .statements = double_binop_1_statements, + .init_globals = (pr_int_t *) double_binop_init, + .expect_globals = (pr_int_t *) double_binop_expect, + }, + { + .desc = "double binop 2", + .extra_globals = 8 * 1, + .num_globals = 8*num_globals(double_binop_init,double_binop_expect), + .num_statements = num_statements (double_binop_2_statements), + .statements = double_binop_2_statements, + .init_globals = (pr_int_t *) double_binop_init, + .expect_globals = (pr_int_t *) double_binop_expect, + }, + { + .desc = "double binop 3a", + .extra_globals = 8 * 1, + .num_globals = 8*num_globals(double_binop_init,double_binop_expect), + .num_statements = num_statements (double_binop_3a_statements), + .statements = double_binop_3a_statements, + .init_globals = (pr_int_t *) double_binop_init, + .expect_globals = (pr_int_t *) double_binop_expect, + }, + { + .desc = "double binop 3b", + .extra_globals = 8 * 1, + .num_globals = 8*num_globals(double_binop_init,double_binop_expect), + .num_statements = num_statements (double_binop_3b_statements), + .statements = double_binop_3b_statements, + .init_globals = (pr_int_t *) double_binop_init, + .expect_globals = (pr_int_t *) double_binop_expect, + }, + { + .desc = "double binop 4", + .extra_globals = 8 * 1, + .num_globals = 8*num_globals(double_binop_init,double_binop_expect), + .num_statements = num_statements (double_binop_4_statements), + .statements = double_binop_4_statements, + .init_globals = (pr_int_t *) double_binop_init, + .expect_globals = (pr_int_t *) double_binop_expect, + }, + { + .desc = "double cos sin", + .extra_globals = 8 * 1, + .num_globals = 8*num_globals(double_cossin_init,double_cossin_expect), + .num_statements = num_statements (double_cossin_statements), + .statements = double_cossin_statements, + .init_globals = (pr_int_t *) double_cossin_init, + .expect_globals = (pr_int_t *) double_cossin_expect, + }, +}; + +#include "main.c" diff --git a/libs/gamecode/test/test-float.c b/libs/gamecode/test/test-float.c new file mode 100644 index 000000000..d974931bb --- /dev/null +++ b/libs/gamecode/test/test-float.c @@ -0,0 +1,192 @@ +#include "head.c" + +#include "QF/mathlib.h" + +#define sq(x) ((float)(x)*(float)(x)) + +static pr_vec4_t float_binop_init[] = { + { 5, -5, 5, -5}, + { 3, 3, -3, -3}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_vec4_t float_binop_expect[] = { + { 5, -5, 5, -5}, + { 3, 3, -3, -3}, + { 15, -15, -15, 15}, + { 1.666666627, -1.666666627, -1.666666627, 1.666666627}, + { 2, -2, 2, -2}, + { 2, 1, -1, -2}, + { 8, -2, 2, -8}, + { 2, -8, 8, -2}, +}; + +static dstatement_t float_binop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 32, -1, 32 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, + { OP(1, 1, 1, OP_MUL_F_1), 0, 4, 8 }, + { OP(1, 1, 1, OP_DIV_F_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_REM_F_1), 0, 4, 16 }, + { OP(1, 1, 1, OP_MOD_F_1), 0, 4, 20 }, + { OP(1, 1, 1, OP_ADD_F_1), 0, 4, 24 }, + { OP(1, 1, 1, OP_SUB_F_1), 0, 4, 28 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t float_binop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // index +//loop: + { OP(0, 0, 0, OP_LEA_C), 32, -2, 32 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, + { OP(1, 1, 1, OP_MUL_F_2), 0, 4, 8 }, + { OP(1, 1, 1, OP_DIV_F_2), 0, 4, 12 }, + { OP(1, 1, 1, OP_REM_F_2), 0, 4, 16 }, + { OP(1, 1, 1, OP_MOD_F_2), 0, 4, 20 }, + { OP(1, 1, 1, OP_ADD_F_2), 0, 4, 24 }, + { OP(1, 1, 1, OP_SUB_F_2), 0, 4, 28 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t float_binop_3a_statements[] = { + { OP(1, 1, 1, OP_MUL_F_3), 0, 4, 8 }, + { OP(1, 1, 1, OP_MUL_F_1), 3, 7, 11 }, + { OP(1, 1, 1, OP_DIV_F_3), 0, 4, 12 }, + { OP(1, 1, 1, OP_DIV_F_1), 3, 7, 15 }, + { OP(1, 1, 1, OP_REM_F_3), 0, 4, 16 }, + { OP(1, 1, 1, OP_REM_F_1), 3, 7, 19 }, + { OP(1, 1, 1, OP_MOD_F_3), 0, 4, 20 }, + { OP(1, 1, 1, OP_MOD_F_1), 3, 7, 23 }, + { OP(1, 1, 1, OP_ADD_F_3), 0, 4, 24 }, + { OP(1, 1, 1, OP_ADD_F_1), 3, 7, 27 }, + { OP(1, 1, 1, OP_SUB_F_3), 0, 4, 28 }, + { OP(1, 1, 1, OP_SUB_F_1), 3, 7, 31 }, +}; + +static dstatement_t float_binop_3b_statements[] = { + { OP(1, 1, 1, OP_MUL_F_1), 0, 4, 8 }, + { OP(1, 1, 1, OP_MUL_F_3), 1, 5, 9 }, + { OP(1, 1, 1, OP_DIV_F_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_DIV_F_3), 1, 5, 13 }, + { OP(1, 1, 1, OP_REM_F_1), 0, 4, 16 }, + { OP(1, 1, 1, OP_REM_F_3), 1, 5, 17 }, + { OP(1, 1, 1, OP_MOD_F_1), 0, 4, 20 }, + { OP(1, 1, 1, OP_MOD_F_3), 1, 5, 21 }, + { OP(1, 1, 1, OP_ADD_F_1), 0, 4, 24 }, + { OP(1, 1, 1, OP_ADD_F_3), 1, 5, 25 }, + { OP(1, 1, 1, OP_SUB_F_1), 0, 4, 28 }, + { OP(1, 1, 1, OP_SUB_F_3), 1, 5, 29 }, +}; + +static dstatement_t float_binop_4_statements[] = { + { OP(1, 1, 1, OP_MUL_F_4), 0, 4, 8 }, + { OP(1, 1, 1, OP_DIV_F_4), 0, 4, 12 }, + { OP(1, 1, 1, OP_REM_F_4), 0, 4, 16 }, + { OP(1, 1, 1, OP_MOD_F_4), 0, 4, 20 }, + { OP(1, 1, 1, OP_ADD_F_4), 0, 4, 24 }, + { OP(1, 1, 1, OP_SUB_F_4), 0, 4, 28 }, +}; + +static pr_vec4_t float_cossin_init[] = { + { 1, 2, 3, 4 }, // 0: output + { M_PI/6, 0, 0, 0 }, // 4: x + { 1, 2, 0, 0 }, // 8: f + { 1, 1, 0, 25 }, // 12: f inc and f0 max + { 0, 0, 0, 0 }, // 16: x2 -> [xx, xx] + // { } // 20: xn +}; + +static pr_vec4_t float_cossin_expect[] = { + { 0.866025388, 0.5, 0, 0 }, // 0: output + { M_PI/6, 0, 0, 0 }, // 4: x + { 25, 26, 0, 0 }, // 8: f + { 1, 1, 0, 25 }, // 12: f inc and f0 max + { -sq(M_PI/6), -sq(M_PI/6), 0, 0 }, // 16: x2 -> [xx, xx] +}; + +static dstatement_t float_cossin_statements[] = { + { OP(0, 0, 0, OP_STORE_A_1), 21, 0, 4 }, // init xn -> [?, x] + { OP(0, 0, 0, OP_STORE_A_1), 20, 0, 8 }, // init xn -> [1, x] + { OP(0, 0, 0, OP_SWIZZLE_F), 4, 0xc000, 16 },// init x2 -> [x, x, 0, 0] + { OP(0, 0, 0, OP_MUL_F_2), 16, 16, 16 }, // x2 -> [x*x, x*x, 0, 0] + { OP(0, 0, 0, OP_SWIZZLE_F), 16, 0xc3e4, 16 },// init x2 -> -x2 + { OP(0, 0, 0, OP_SUB_F_4), 0, 0, 0 }, // init acc (output) to 0 +// loop: + { OP(0, 0, 0, OP_ADD_F_2), 0, 20, 0 }, // acc += xn + { OP(0, 0, 0, OP_MUL_F_2), 20, 16, 20 }, // xn *= x2 + { OP(0, 0, 0, OP_DIV_F_2), 20, 8, 20 }, // xn /= f + { OP(0, 0, 0, OP_ADD_F_2), 8, 12, 8 }, // f += inc + { OP(0, 0, 0, OP_DIV_F_2), 20, 8, 20 }, // xn /= f + { OP(0, 0, 0, OP_ADD_F_2), 8, 12, 8 }, // f += inc + { OP(0, 0, 0, OP_LT_F_1), 8, 15, 23 }, // f0 < fmax + { OP(0, 0, 0, OP_IF_A), -7, 0, 23 }, // f0 < fmax +}; + +test_t tests[] = { + { + .desc = "float binop 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_binop_init,float_binop_expect), + .num_statements = num_statements (float_binop_1_statements), + .statements = float_binop_1_statements, + .init_globals = (pr_int_t *) float_binop_init, + .expect_globals = (pr_int_t *) float_binop_expect, + }, + { + .desc = "float binop 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_binop_init,float_binop_expect), + .num_statements = num_statements (float_binop_2_statements), + .statements = float_binop_2_statements, + .init_globals = (pr_int_t *) float_binop_init, + .expect_globals = (pr_int_t *) float_binop_expect, + }, + { + .desc = "float binop 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_binop_init,float_binop_expect), + .num_statements = num_statements (float_binop_3a_statements), + .statements = float_binop_3a_statements, + .init_globals = (pr_int_t *) float_binop_init, + .expect_globals = (pr_int_t *) float_binop_expect, + }, + { + .desc = "float binop 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_binop_init,float_binop_expect), + .num_statements = num_statements (float_binop_3b_statements), + .statements = float_binop_3b_statements, + .init_globals = (pr_int_t *) float_binop_init, + .expect_globals = (pr_int_t *) float_binop_expect, + }, + { + .desc = "float binop 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_binop_init,float_binop_expect), + .num_statements = num_statements (float_binop_4_statements), + .statements = float_binop_4_statements, + .init_globals = (pr_int_t *) float_binop_init, + .expect_globals = (pr_int_t *) float_binop_expect, + }, + { + .desc = "float cos sin", + .extra_globals = 4 * 1, + .num_globals = 4 * num_globals (float_cossin_init, float_cossin_expect), + .num_statements = num_statements (float_cossin_statements), + .statements = float_cossin_statements, + .init_globals = (pr_int_t *) float_cossin_init, + .expect_globals = (pr_int_t *) float_cossin_expect, + }, +}; + +#include "main.c" diff --git a/libs/gamecode/test/test-int.c b/libs/gamecode/test/test-int.c new file mode 100644 index 000000000..08cfe3596 --- /dev/null +++ b/libs/gamecode/test/test-int.c @@ -0,0 +1,146 @@ +#include "head.c" + +#include "QF/mathlib.h" + +static pr_ivec4_t int_binop_init[] = { + { 5, -5, 5, -5}, + { 3, 3, -3, -3}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_ivec4_t int_binop_expect[] = { + { 5, -5, 5, -5}, + { 3, 3, -3, -3}, + { 15, -15, -15, 15}, + { 1, -1, -1, 1}, + { 2, -2, 2, -2}, + { 2, 1, -1, -2}, + { 8, -2, 2, -8}, + { 2, -8, 8, -2}, +}; + +static dstatement_t int_binop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 32, -1, 32 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, + { OP(1, 1, 1, OP_MUL_I_1), 0, 4, 8 }, + { OP(1, 1, 1, OP_DIV_I_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_REM_I_1), 0, 4, 16 }, + { OP(1, 1, 1, OP_MOD_I_1), 0, 4, 20 }, + { OP(1, 1, 1, OP_ADD_I_1), 0, 4, 24 }, + { OP(1, 1, 1, OP_SUB_I_1), 0, 4, 28 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t int_binop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // index +//loop: + { OP(0, 0, 0, OP_LEA_C), 32, -2, 32 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, + { OP(1, 1, 1, OP_MUL_I_2), 0, 4, 8 }, + { OP(1, 1, 1, OP_DIV_I_2), 0, 4, 12 }, + { OP(1, 1, 1, OP_REM_I_2), 0, 4, 16 }, + { OP(1, 1, 1, OP_MOD_I_2), 0, 4, 20 }, + { OP(1, 1, 1, OP_ADD_I_2), 0, 4, 24 }, + { OP(1, 1, 1, OP_SUB_I_2), 0, 4, 28 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t int_binop_3a_statements[] = { + { OP(1, 1, 1, OP_MUL_I_3), 0, 4, 8 }, + { OP(1, 1, 1, OP_MUL_I_1), 3, 7, 11 }, + { OP(1, 1, 1, OP_DIV_I_3), 0, 4, 12 }, + { OP(1, 1, 1, OP_DIV_I_1), 3, 7, 15 }, + { OP(1, 1, 1, OP_REM_I_3), 0, 4, 16 }, + { OP(1, 1, 1, OP_REM_I_1), 3, 7, 19 }, + { OP(1, 1, 1, OP_MOD_I_3), 0, 4, 20 }, + { OP(1, 1, 1, OP_MOD_I_1), 3, 7, 23 }, + { OP(1, 1, 1, OP_ADD_I_3), 0, 4, 24 }, + { OP(1, 1, 1, OP_ADD_I_1), 3, 7, 27 }, + { OP(1, 1, 1, OP_SUB_I_3), 0, 4, 28 }, + { OP(1, 1, 1, OP_SUB_I_1), 3, 7, 31 }, +}; + +static dstatement_t int_binop_3b_statements[] = { + { OP(1, 1, 1, OP_MUL_I_1), 0, 4, 8 }, + { OP(1, 1, 1, OP_MUL_I_3), 1, 5, 9 }, + { OP(1, 1, 1, OP_DIV_I_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_DIV_I_3), 1, 5, 13 }, + { OP(1, 1, 1, OP_REM_I_1), 0, 4, 16 }, + { OP(1, 1, 1, OP_REM_I_3), 1, 5, 17 }, + { OP(1, 1, 1, OP_MOD_I_1), 0, 4, 20 }, + { OP(1, 1, 1, OP_MOD_I_3), 1, 5, 21 }, + { OP(1, 1, 1, OP_ADD_I_1), 0, 4, 24 }, + { OP(1, 1, 1, OP_ADD_I_3), 1, 5, 25 }, + { OP(1, 1, 1, OP_SUB_I_1), 0, 4, 28 }, + { OP(1, 1, 1, OP_SUB_I_3), 1, 5, 29 }, +}; + +static dstatement_t int_binop_4_statements[] = { + { OP(1, 1, 1, OP_MUL_I_4), 0, 4, 8 }, + { OP(1, 1, 1, OP_DIV_I_4), 0, 4, 12 }, + { OP(1, 1, 1, OP_REM_I_4), 0, 4, 16 }, + { OP(1, 1, 1, OP_MOD_I_4), 0, 4, 20 }, + { OP(1, 1, 1, OP_ADD_I_4), 0, 4, 24 }, + { OP(1, 1, 1, OP_SUB_I_4), 0, 4, 28 }, +}; + +test_t tests[] = { + { + .desc = "int binop 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_binop_init,int_binop_expect), + .num_statements = num_statements (int_binop_1_statements), + .statements = int_binop_1_statements, + .init_globals = (pr_int_t *) int_binop_init, + .expect_globals = (pr_int_t *) int_binop_expect, + }, + { + .desc = "int binop 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_binop_init,int_binop_expect), + .num_statements = num_statements (int_binop_2_statements), + .statements = int_binop_2_statements, + .init_globals = (pr_int_t *) int_binop_init, + .expect_globals = (pr_int_t *) int_binop_expect, + }, + { + .desc = "int binop 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_binop_init,int_binop_expect), + .num_statements = num_statements (int_binop_3a_statements), + .statements = int_binop_3a_statements, + .init_globals = (pr_int_t *) int_binop_init, + .expect_globals = (pr_int_t *) int_binop_expect, + }, + { + .desc = "int binop 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_binop_init,int_binop_expect), + .num_statements = num_statements (int_binop_3b_statements), + .statements = int_binop_3b_statements, + .init_globals = (pr_int_t *) int_binop_init, + .expect_globals = (pr_int_t *) int_binop_expect, + }, + { + .desc = "int binop 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_binop_init,int_binop_expect), + .num_statements = num_statements (int_binop_4_statements), + .statements = int_binop_4_statements, + .init_globals = (pr_int_t *) int_binop_init, + .expect_globals = (pr_int_t *) int_binop_expect, + }, +}; + +#include "main.c" diff --git a/libs/gamecode/test/test-long.c b/libs/gamecode/test/test-long.c new file mode 100644 index 000000000..7777b38e0 --- /dev/null +++ b/libs/gamecode/test/test-long.c @@ -0,0 +1,148 @@ +#include "head.c" + +#include "QF/mathlib.h" + +#define sq(x) ((x)*(x)) + +static pr_lvec4_t long_binop_init[] = { + { 5, -5, 5, -5}, + { 3, 3, -3, -3}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_lvec4_t long_binop_expect[] = { + { 5, -5, 5, -5}, + { 3, 3, -3, -3}, + { 15, -15, -15, 15}, + { 5.0/3, -5.0/3, -5.0/3, 5.0/3}, + { 2, -2, 2, -2}, + { 2, 1, -1, -2}, + { 8, -2, 2, -8}, + { 2, -8, 8, -2}, +}; + +static dstatement_t long_binop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 64, -2, 64 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, + { OP(1, 1, 1, OP_MUL_L_1), 0, 8, 16 }, + { OP(1, 1, 1, OP_DIV_L_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_REM_L_1), 0, 8, 32 }, + { OP(1, 1, 1, OP_MOD_L_1), 0, 8, 40 }, + { OP(1, 1, 1, OP_ADD_L_1), 0, 8, 48 }, + { OP(1, 1, 1, OP_SUB_L_1), 0, 8, 56 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t long_binop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 64, -4, 64 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, + { OP(1, 1, 1, OP_MUL_L_2), 0, 8, 16 }, + { OP(1, 1, 1, OP_DIV_L_2), 0, 8, 24 }, + { OP(1, 1, 1, OP_REM_L_2), 0, 8, 32 }, + { OP(1, 1, 1, OP_MOD_L_2), 0, 8, 40 }, + { OP(1, 1, 1, OP_ADD_L_2), 0, 8, 48 }, + { OP(1, 1, 1, OP_SUB_L_2), 0, 8, 56 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t long_binop_3a_statements[] = { + { OP(1, 1, 1, OP_MUL_L_3), 0, 8, 16 }, + { OP(1, 1, 1, OP_MUL_L_1), 6, 14, 22 }, + { OP(1, 1, 1, OP_DIV_L_3), 0, 8, 24 }, + { OP(1, 1, 1, OP_DIV_L_1), 6, 14, 30 }, + { OP(1, 1, 1, OP_REM_L_3), 0, 8, 32 }, + { OP(1, 1, 1, OP_REM_L_1), 6, 14, 38 }, + { OP(1, 1, 1, OP_MOD_L_3), 0, 8, 40 }, + { OP(1, 1, 1, OP_MOD_L_1), 6, 14, 46 }, + { OP(1, 1, 1, OP_ADD_L_3), 0, 8, 48 }, + { OP(1, 1, 1, OP_ADD_L_1), 6, 14, 54 }, + { OP(1, 1, 1, OP_SUB_L_3), 0, 8, 56 }, + { OP(1, 1, 1, OP_SUB_L_1), 6, 14, 62 }, +}; + +static dstatement_t long_binop_3b_statements[] = { + { OP(1, 1, 1, OP_MUL_L_1), 0, 8, 16 }, + { OP(1, 1, 1, OP_MUL_L_3), 2, 10, 18 }, + { OP(1, 1, 1, OP_DIV_L_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_DIV_L_3), 2, 10, 26 }, + { OP(1, 1, 1, OP_REM_L_1), 0, 8, 32 }, + { OP(1, 1, 1, OP_REM_L_3), 2, 10, 34 }, + { OP(1, 1, 1, OP_MOD_L_1), 0, 8, 40 }, + { OP(1, 1, 1, OP_MOD_L_3), 2, 10, 42 }, + { OP(1, 1, 1, OP_ADD_L_1), 0, 8, 48 }, + { OP(1, 1, 1, OP_ADD_L_3), 2, 10, 50 }, + { OP(1, 1, 1, OP_SUB_L_1), 0, 8, 56 }, + { OP(1, 1, 1, OP_SUB_L_3), 2, 10, 58 }, +}; + +static dstatement_t long_binop_4_statements[] = { + { OP(1, 1, 1, OP_MUL_L_4), 0, 8, 16 }, + { OP(1, 1, 1, OP_DIV_L_4), 0, 8, 24 }, + { OP(1, 1, 1, OP_REM_L_4), 0, 8, 32 }, + { OP(1, 1, 1, OP_MOD_L_4), 0, 8, 40 }, + { OP(1, 1, 1, OP_ADD_L_4), 0, 8, 48 }, + { OP(1, 1, 1, OP_SUB_L_4), 0, 8, 56 }, +}; + +test_t tests[] = { + { + .desc = "long binop 1", + .extra_globals = 8 * 1, + .num_globals = 8*num_globals(long_binop_init,long_binop_expect), + .num_statements = num_statements (long_binop_1_statements), + .statements = long_binop_1_statements, + .init_globals = (pr_int_t *) long_binop_init, + .expect_globals = (pr_int_t *) long_binop_expect, + }, + { + .desc = "long binop 2", + .extra_globals = 8 * 1, + .num_globals = 8*num_globals(long_binop_init,long_binop_expect), + .num_statements = num_statements (long_binop_2_statements), + .statements = long_binop_2_statements, + .init_globals = (pr_int_t *) long_binop_init, + .expect_globals = (pr_int_t *) long_binop_expect, + }, + { + .desc = "long binop 3a", + .extra_globals = 8 * 1, + .num_globals = 8*num_globals(long_binop_init,long_binop_expect), + .num_statements = num_statements (long_binop_3a_statements), + .statements = long_binop_3a_statements, + .init_globals = (pr_int_t *) long_binop_init, + .expect_globals = (pr_int_t *) long_binop_expect, + }, + { + .desc = "long binop 3b", + .extra_globals = 8 * 1, + .num_globals = 8*num_globals(long_binop_init,long_binop_expect), + .num_statements = num_statements (long_binop_3b_statements), + .statements = long_binop_3b_statements, + .init_globals = (pr_int_t *) long_binop_init, + .expect_globals = (pr_int_t *) long_binop_expect, + }, + { + .desc = "long binop 4", + .extra_globals = 8 * 1, + .num_globals = 8*num_globals(long_binop_init,long_binop_expect), + .num_statements = num_statements (long_binop_4_statements), + .statements = long_binop_4_statements, + .init_globals = (pr_int_t *) long_binop_init, + .expect_globals = (pr_int_t *) long_binop_expect, + }, +}; + +#include "main.c" From f2b258ba7602a41cdb9a99eadf5b55e18e495b74 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 4 Jan 2022 17:53:10 +0900 Subject: [PATCH 034/360] [gamecode] Add statement bounds checking Statements can be bounds checked in the one place (jump calculation), but memory accesses cannot as they can be used in lea instructions which should never cause an exception (unless one of lea's operands is OOB). --- libs/gamecode/pr_exec.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 764b844ce..4ed1be891 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1819,6 +1819,9 @@ pr_jump_mode (progs_t *pr, const dstatement_t *st) jump_offs = OPA(uint) + OPB(int); break; } + if (pr_boundscheck->int_val && jump_offs >= pr->progs->numstatements) { + PR_RunError (pr, "out of bounds: %x", jump_offs); + } return jump_offs - 1; // for st++ } From 2f09ece65bc2889e2a41b2a9ca6d6877ff31aa88 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 4 Jan 2022 17:55:20 +0900 Subject: [PATCH 035/360] [gamecode] Add more modes to WITH It turned out I had no way of using a pointer or field as the value to load, so all 4 modes are duplicated with loads from where operand b points, but the loaded value interpreted the same way. Also, fixed an error in the calculation of op-b offsets. --- libs/gamecode/pr_exec.c | 20 +++++++++++++++++--- 1 file changed, 17 insertions(+), 3 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 4ed1be891..6ceebfca0 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1828,21 +1828,35 @@ pr_jump_mode (progs_t *pr, const dstatement_t *st) static pr_pointer_t __attribute__((pure)) pr_with (progs_t *pr, const dstatement_t *st) { - pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, A); pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; + pr_type_t *op_b = pr->pr_globals + PR_BASE (pr, st, B) + st->b; + switch (st->a) { + // fixed offset case 0: // hard-0 base return st->b; case 1: // relative to current base - return op_b - pr->pr_globals; + return PR_BASE (pr, st, B) + st->b; case 2: // relative to stack (-ve offset) return *pr->globals.stack + (pr_short_t) st->b; case 3: // relative to edict_area (+ve only) return edict_area + st->b; + + case 4: + // hard-0 base + return pr->pr_globals[st->b].pointer_var; + case 5: + return OPB(pointer); + case 6: + // relative to stack (-ve offset) + return *pr->globals.stack + OPB(int); + case 7: + // relative to edict_area (+ve only) + return edict_area + OPB(uint); } PR_RunError (pr, "Invalid with index: %u", st->a); } @@ -2875,7 +2889,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) } break; case OP_WITH: - pr->pr_bases[st->c] = pr_with (pr, st); + pr->pr_bases[st->c & 3] = pr_with (pr, st); break; case OP_STATE_ft: { From 63db48bf426515e5f1d5a8fcea814fd744216806 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 4 Jan 2022 18:23:32 +0900 Subject: [PATCH 036/360] [simd] Add integral loadvec3 versions that set w to 1 Always setting w to 0 made it impossible to use the resulting 4d vectors in division-based operations as they would result in divide-by-zero and thus an unavoidable exception (CPUs don't like integer div-by-zero). I'll probably add similar for float and double, but they're not as critical as they'll just give inf or nan. This also increases my doubts about the value of keeping 3d vector operations. --- include/QF/simd/vec4d.h | 13 +++++++++++++ include/QF/simd/vec4i.h | 13 +++++++++++++ 2 files changed, 26 insertions(+) diff --git a/include/QF/simd/vec4d.h b/include/QF/simd/vec4d.h index 3b87eb14a..d0e3f19bc 100644 --- a/include/QF/simd/vec4d.h +++ b/include/QF/simd/vec4d.h @@ -97,6 +97,7 @@ GNU89INLINE inline vec4d_t qconjd (vec4d_t q) __attribute__((const)); GNU89INLINE inline vec4d_t loadvec3d (const double v3[]) __attribute__((pure)); GNU89INLINE inline void storevec3d (double v3[3], vec4d_t v4); GNU89INLINE inline vec4l_t loadvec3l (const long *v3) __attribute__((pure)); +GNU89INLINE inline vec4l_t loadvec3l1 (const long *v3) __attribute__((pure)); GNU89INLINE inline void storevec3l (long *v3, vec4l_t v4); #ifndef IMPLEMENT_VEC4D_Funcs @@ -307,6 +308,18 @@ loadvec3l (const long *v3) return v4; } +#ifndef IMPLEMENT_VEC4F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec4l_t +loadvec3l1 (const long *v3) +{ + vec4l_t v4 = { v3[0], v3[1], v3[2], 1 }; + return v4; +} + #ifndef IMPLEMENT_VEC4F_Funcs GNU89INLINE inline #else diff --git a/include/QF/simd/vec4i.h b/include/QF/simd/vec4i.h index 6320cd83a..db303e610 100644 --- a/include/QF/simd/vec4i.h +++ b/include/QF/simd/vec4i.h @@ -38,6 +38,7 @@ GNU89INLINE inline int any4i (vec4i_t v) __attribute__((const)); GNU89INLINE inline int all4i (vec4i_t v) __attribute__((const)); GNU89INLINE inline int none4i (vec4i_t v) __attribute__((const)); GNU89INLINE inline vec4i_t loadvec3i (const int *v3) __attribute__((pure)); +GNU89INLINE inline vec4i_t loadvec3i1 (const int *v3) __attribute__((pure)); GNU89INLINE inline void storevec3i (int *v3, vec4i_t v4); #ifndef IMPLEMENT_VEC4F_Funcs @@ -107,6 +108,18 @@ loadvec3i (const int *v3) return v4; } +#ifndef IMPLEMENT_VEC4F_Funcs +GNU89INLINE inline +#else +VISIBLE +#endif +vec4i_t +loadvec3i1 (const int *v3) +{ + vec4i_t v4 = { v3[0], v3[1], v3[2], 1 }; + return v4; +} + #ifndef IMPLEMENT_VEC4F_Funcs GNU89INLINE inline #else From 59292393e6964e1da3dc3aa065b57d6749df7ab4 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 4 Jan 2022 18:36:13 +0900 Subject: [PATCH 037/360] [gamecode] Fix up MOD (%%) for integral types Use the new "1" versions of loadvec3 to get a 1 in w to avoid divide-by-zero errors, and use the correct type for longs (forgot to change i to l on the vector types). --- libs/gamecode/pr_exec.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 6ceebfca0..851c24a49 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -3133,6 +3133,11 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) // 1 0001 OP_op(DIV, /); +// implement remainder (c %) for integers: +// 5 rem 3 = 2 +// -5 rem 3 = -2 +// 5 rem -3 = 2 +// -5 rem -3 = -2 #define OP_store(d, s) *(d) = s #define OP_remmod_T(OP, T, n, t, l, f, s) \ case OP_##OP##_##T##_##n: \ @@ -3157,9 +3162,9 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OP_rem_T (D, 3, double, loadvec3d, vtrunc4d, storevec3d); OP_rem_T (D, 4, dvec4, *, vtrunc4d, OP_store); -// implement true modulo for integers: -// 5 mod 3 = 2 -// -5 mod 3 = 1 +// implement true modulo (python %) for integers: +// 5 mod 3 = 2 +// -5 mod 3 = 1 // 5 mod -3 = -1 // -5 mod -3 = -2 #define OP_mod_Ti(T, n, t, l, m, s) \ @@ -3183,16 +3188,16 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) // 1 0011 OP_mod_Ti (I, 1, int, *, -, OP_store); OP_mod_Ti (I, 2, ivec2, *, +, OP_store); - OP_mod_Ti (I, 3, int, loadvec3i, +, storevec3i); + OP_mod_Ti (I, 3, int, loadvec3i1, +, storevec3i); OP_mod_Ti (I, 4, ivec4, *, +, OP_store); OP_mod_Tf (F, 1, float, *, floorf, OP_store); OP_mod_Tf (F, 2, vec2, *, vfloor2f, OP_store); OP_mod_Tf (F, 3, float, loadvec3f, vfloor4f, storevec3f); OP_mod_Tf (F, 4, vec4, *, vfloor4f, OP_store); OP_mod_Ti (L, 1, long, *, -, OP_store); - OP_mod_Ti (L, 2, ivec2, *, +, OP_store); - OP_mod_Ti (L, 3, long, loadvec3l, +, storevec3l); - OP_mod_Ti (L, 4, ivec4, *, +, OP_store); + OP_mod_Ti (L, 2, lvec2, *, +, OP_store); + OP_mod_Ti (L, 3, long, loadvec3l1, +, storevec3l); + OP_mod_Ti (L, 4, lvec4, *, +, OP_store); OP_mod_Tf (D, 1, double, *, floor, OP_store); OP_mod_Tf (D, 2, dvec2, *, vfloor2d, OP_store); OP_mod_Tf (D, 3, double, loadvec3d, vfloor4d, storevec3d); From 35387b5450da4045f0d70319f29c8996f4cd14b7 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 4 Jan 2022 19:01:05 +0900 Subject: [PATCH 038/360] [gamecode] Fix a pile of incorrect base register refs The problem with copying code is it's all to easy to forget to make all necessary edits. --- libs/gamecode/pr_exec.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 851c24a49..80373aaf3 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1738,7 +1738,7 @@ static pr_type_t * pr_entity_mode (progs_t *pr, const dstatement_t *st, int shift) { pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); - pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, A); + pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, B); int mm_ind = (st->op >> shift) & 3; pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; pointer_t mm_offs = 0; @@ -1768,7 +1768,7 @@ static pr_type_t * pr_address_mode (progs_t *pr, const dstatement_t *st, int shift) { pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); - pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, A); + pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, B); int mm_ind = (st->op >> shift) & 3; pointer_t mm_offs = 0; @@ -1793,11 +1793,11 @@ pr_address_mode (progs_t *pr, const dstatement_t *st, int shift) return pr->pr_globals + mm_offs; } -static pr_pointer_t +static pr_pointer_t __attribute__((pure)) pr_jump_mode (progs_t *pr, const dstatement_t *st) { pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); - pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, A); + pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, B); int jump_ind = st->op & 3; pointer_t jump_offs = pr->pr_xstatement; @@ -2675,8 +2675,8 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) } pointer_t st_a = st->a + PR_BASE (pr, st, A); - pointer_t st_b = st->b + PR_BASE (pr, st, A); - pointer_t st_c = st->c + PR_BASE (pr, st, A); + pointer_t st_b = st->b + PR_BASE (pr, st, B); + pointer_t st_c = st->c + PR_BASE (pr, st, C); pr_type_t *op_a = pr->pr_globals + st_a; From 6d9c63999ca1353ffeee85ed99356f5e115c0132 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 4 Jan 2022 20:45:45 +0900 Subject: [PATCH 039/360] [gamecode] Rename pr_opcode.c Just to make way for new tables :) --- libs/gamecode/Makemodule.am | 2 +- libs/gamecode/{pr_opcode.c => pr_v6p_opcode.c} | 10 ++++------ 2 files changed, 5 insertions(+), 7 deletions(-) rename libs/gamecode/{pr_opcode.c => pr_v6p_opcode.c} (99%) diff --git a/libs/gamecode/Makemodule.am b/libs/gamecode/Makemodule.am index b962f60ad..af7a3d5a2 100644 --- a/libs/gamecode/Makemodule.am +++ b/libs/gamecode/Makemodule.am @@ -14,8 +14,8 @@ libs_gamecode_libQFgamecode_la_SOURCES= \ libs/gamecode/pr_exec.c \ libs/gamecode/pr_load.c \ libs/gamecode/pr_parse.c \ - libs/gamecode/pr_opcode.c \ libs/gamecode/pr_resolve.c \ libs/gamecode/pr_resource.c \ libs/gamecode/pr_strings.c \ + libs/gamecode/pr_v6p_opcode.c \ libs/gamecode/pr_zone.c diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_v6p_opcode.c similarity index 99% rename from libs/gamecode/pr_opcode.c rename to libs/gamecode/pr_v6p_opcode.c index aff4784de..a4ed63d44 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -1,12 +1,10 @@ /* - #FILENAME# + pr_v6p_opcodes.c - #DESCRIPTION# + Opcode table and checking for v6+ progs. - Copyright (C) 2001 #AUTHOR# - - Author: #AUTHOR# - Date: #DATE# + Copyright (C) 1996-1997 Id Software, Inc. + Copyright (C) 2001 Bill Currie This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License From 0b674f5ed4e31adad6a5217eb07c4d616e37717d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 5 Jan 2022 19:04:43 +0900 Subject: [PATCH 040/360] [gamecode] Clean up some opcode names While working on the new opcode table, I decided a lot of the names were not to my liking. Part of the problem was the earlier clash with the v6p opcode names, but that has been resolved via the v6p tag. --- include/QF/pr_comp.h | 36 ++++++++++---------- libs/gamecode/pr_exec.c | 48 +++++++++++++-------------- libs/gamecode/test/test-vector.c | 56 ++++++++++++++++---------------- 3 files changed, 70 insertions(+), 70 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index d72ced1ca..2785d6913 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -464,10 +464,10 @@ typedef enum { // C complex // V vector (3d) // Q quaternion - OP_DOT_CC_F, OP_DOT_VV_F, OP_DOT_QQ_F, OP_CROSS_VV_F, - OP_MUL_CC_F, OP_MUL_QV_F, OP_MUL_VQ_F, OP_MUL_QQ_F, - OP_DOT_CC_D, OP_DOT_VV_D, OP_DOT_QQ_D, OP_CROSS_VV_D, - OP_MUL_CC_D, OP_MUL_QV_D, OP_MUL_VQ_D, OP_MUL_QQ_D, + OP_CDOT_F, OP_VDOT_F, OP_QDOT_F, OP_CROSS_F, + OP_CMUL_F, OP_QVMUL_F, OP_VQMUL_F, OP_QMUL_F, + OP_CDOT_D, OP_VDOT_D, OP_QDOT_D, OP_CROSS_D, + OP_CMUL_D, OP_QVMUL_D, OP_VQMUL_D, OP_QMUL_D, // comparison // 0 1000 == OP_EQ_I_1, OP_EQ_I_2, OP_EQ_I_3, OP_EQ_I_4, @@ -547,9 +547,9 @@ typedef enum { OP_SHL_L_1, OP_SHL_L_2, OP_SHL_L_3, OP_SHL_L_4, OP_CMP_S, OP_GE_S, OP_LE_S, OP_NOT_S, //OP_CMP_S doubles as NE // 1 0111 c = a >> b - OP_SHR_I_1, OP_SHR_I_2, OP_SHR_I_3, OP_SHR_I_4, + OP_ASR_I_1, OP_ASR_I_2, OP_ASR_I_3, OP_ASR_I_4, OP_SHR_u_1, OP_SHR_u_2, OP_SHR_u_3, OP_SHR_u_4, - OP_SHR_L_1, OP_SHR_L_2, OP_SHR_L_3, OP_SHR_L_4, + OP_ASR_L_1, OP_ASR_L_2, OP_ASR_L_3, OP_ASR_L_4, OP_SHR_U_1, OP_SHR_U_2, OP_SHR_U_3, OP_SHR_U_4, // 1 1000 c = a (& | ^) b or ~a (bitwise ops) OP_BITAND_I_1, OP_BITAND_I_2, OP_BITAND_I_3, OP_BITAND_I_4, @@ -563,29 +563,29 @@ typedef enum { OP_SWIZZLE_D, OP_SCALE_D_2, OP_SCALE_D_3, OP_SCALE_D_4, // 1 1010 > unsigned and conversions OP_GT_u_1, OP_GT_u_2, OP_GT_u_3, OP_GT_u_4, - OP_CONV_IF_1, OP_CONV_LD_1, OP_CONV_uF_1, OP_CONV_UD_1, + OP_CONV_IF, OP_CONV_LD, OP_CONV_uF, OP_CONV_UD, OP_GT_U_1, OP_GT_U_2, OP_GT_U_3, OP_GT_U_4, - OP_CONV_FI_1, OP_CONV_DL_1, OP_CONV_Fu_1, OP_CONV_DU_1, + OP_CONV_FI, OP_CONV_DL, OP_CONV_Fu, OP_CONV_DU, // 1 1011 lea, with, etc - OP_LEA_A, OP_LEA_B, OP_LEA_C, OP_LEA_D, - OP_LEA_E, OP_ANY_2, OP_ANY_3, OP_ANY_4, - OP_PUSHREG, OP_ALL_2, OP_ALL_3, OP_ALL_4, - OP_POPREG, OP_NONE_2, OP_NONE_3, OP_NONE_4, + OP_LEA_A, OP_LEA_B, OP_LEA_C, OP_LEA_D, + OP_LEA_E, OP_ANY_2, OP_ANY_3, OP_ANY_4, + OP_PUSHREGS, OP_ALL_2, OP_ALL_3, OP_ALL_4, + OP_POPREGS, OP_NONE_2, OP_NONE_3, OP_NONE_4, // 1 1100 c = a (&& || ^^) b or !a (logical ops (no short circuit)) OP_AND_I_1, OP_AND_I_2, OP_AND_I_3, OP_AND_I_4, OP_OR_I_1, OP_OR_I_2, OP_OR_I_3, OP_OR_I_4, OP_XOR_I_1, OP_XOR_I_2, OP_XOR_I_3, OP_XOR_I_4, OP_NOT_I_1, OP_NOT_I_2, OP_NOT_I_3, OP_NOT_I_4, // 1 1101 >= unsigned with q v4 mul and moves mixed in - OP_GE_u_1, OP_GE_u_2, OP_GE_u_3, OP_GE_u_4, - OP_MUL_QV4_F, OP_MOVE_I, OP_MOVE_P, OP_MOVE_PI, - OP_GE_U_1, OP_GE_U_2, OP_GE_U_3, OP_GE_U_4, - OP_MUL_QV4_D, OP_MEMSET_I, OP_MEMSET_P, OP_MEMSET_PI, + OP_GE_u_1, OP_GE_u_2, OP_GE_u_3, OP_GE_u_4, + OP_QV4MUL_F, OP_MOVE_I, OP_MOVE_P, OP_MOVE_PI, + OP_GE_U_1, OP_GE_U_2, OP_GE_U_3, OP_GE_U_4, + OP_QV4MUL_D, OP_MEMSET_I, OP_MEMSET_P, OP_MEMSET_PI, // 1 1110 <= unsigned with v4 q mul and conversion mixed in OP_LE_u_1, OP_LE_u_2, OP_LE_u_3, OP_LE_u_4, - OP_MUL_V4Q_F, OP_CONV_IL_1, OP_CONV_uU_1, OP_CONV_FD_1, + OP_V4QMUL_F, OP_CONV_IL_1, OP_CONV_uU_1, OP_CONV_FD_1, OP_LE_U_1, OP_LE_U_2, OP_LE_U_3, OP_LE_U_4, - OP_MUL_V4Q_D, OP_CONV_LI_1, OP_CONV_Uu_1, OP_CONV_DF_1, + OP_V4QMUL_D, OP_CONV_LI_1, OP_CONV_Uu_1, OP_CONV_DF_1, // 1 1111 OP_spare_33, OP_spare_34, OP_spare_35, OP_spare_36, OP_spare_37, OP_spare_38, OP_spare_39, OP_spare_40, diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 80373aaf3..717364ea3 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -2953,20 +2953,20 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) } break; // 0 0111 - case OP_DOT_CC_F: + case OP_CDOT_F: OPC(vec2) = dot2f (OPA(vec2), OPB(vec2)); break; - case OP_DOT_VV_F: + case OP_VDOT_F: { vec_t d = DotProduct (&OPA(float), &OPB(float)); VectorSet (d, d, d, &OPC(float)); } break; - case OP_DOT_QQ_F: + case OP_QDOT_F: OPC(vec4) = dotf (OPA(vec4), OPB(vec4)); break; - case OP_CROSS_VV_F: + case OP_CROSS_F: { pr_vec4_t a = loadvec3f (&OPA(float)); pr_vec4_t b = loadvec3f (&OPB(float)); @@ -2974,40 +2974,40 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) storevec3f (&OPC(float), c); } break; - case OP_MUL_CC_F: + case OP_CMUL_F: OPC(vec2) = cmulf (OPA(vec2), OPB(vec2)); break; - case OP_MUL_QV_F: + case OP_QVMUL_F: { pr_vec4_t v = loadvec3f (&OPB(float)); v = qvmulf (OPA(vec4), v); storevec3f (&OPC(float), v); } break; - case OP_MUL_VQ_F: + case OP_VQMUL_F: { pr_vec4_t v = loadvec3f (&OPA(float)); v = vqmulf (v, OPB(vec4)); storevec3f (&OPC(float), v); } break; - case OP_MUL_QQ_F: + case OP_QMUL_F: OPC(vec4) = qmulf (OPA(vec4), OPB(vec4)); break; - case OP_DOT_CC_D: + case OP_CDOT_D: OPC(dvec2) = dot2d (OPA(dvec2), OPB(dvec2)); break; - case OP_DOT_VV_D: + case OP_VDOT_D: { double d = DotProduct (&OPA(double), &OPB(double)); VectorSet (d, d, d, &OPC(double)); } break; - case OP_DOT_QQ_D: + case OP_QDOT_D: OPC(dvec4) = dotd (OPA(dvec4), OPB(dvec4)); break; - case OP_CROSS_VV_D: + case OP_CROSS_D: { pr_dvec4_t a = loadvec3d (&OPA(double)); pr_dvec4_t b = loadvec3d (&OPB(double)); @@ -3015,24 +3015,24 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) storevec3d (&OPC(double), c); } break; - case OP_MUL_CC_D: + case OP_CMUL_D: OPC(dvec2) = cmuld (OPA(dvec2), OPB(dvec2)); break; - case OP_MUL_QV_D: + case OP_QVMUL_D: { pr_dvec4_t v = loadvec3d (&OPB(double)); v = qvmuld (OPA(dvec4), v); storevec3d (&OPC(double), v); } break; - case OP_MUL_VQ_D: + case OP_VQMUL_D: { pr_dvec4_t v = loadvec3d (&OPA(double)); v = vqmuld (v, OPB(dvec4)); storevec3d (&OPC(double), v); } break; - case OP_MUL_QQ_D: + case OP_QMUL_D: OPC(dvec4) = qmuld (OPA(dvec4), OPB(dvec4)); break; @@ -3239,9 +3239,9 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OPC(int) = !OPA(string) || !*PR_GetString (pr, OPA(string)); break; // 1 0111 - OP_op_T (SHR, I, int, ivec2, ivec4, >>); + OP_op_T (ASR, I, int, ivec2, ivec4, >>); OP_op_T (SHR, u, uint, uivec2, uivec4, >>); - OP_op_T (SHR, L, long, lvec2, lvec4, >>); + OP_op_T (ASR, L, long, lvec2, lvec4, >>); OP_op_T (SHR, U, ulong, ulvec2, ulvec4, >>); // 1 1000 OP_op_T (BITAND, I, int, ivec2, ivec4, &); @@ -3293,7 +3293,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_ANY_4: OPC(int) = any4i (OPA(ivec4)); break; - case OP_PUSHREG: + case OP_PUSHREGS: stk = pr_stack_push (pr); STK(uivec4) = pr->pr_bases; break; @@ -3310,7 +3310,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_ALL_4: OPC(int) = all4i (OPA(ivec4)); break; - case OP_POPREG: + case OP_POPREGS: stk = pr_stack_pop (pr); pr->pr_bases = STK(uivec4); break; @@ -3365,7 +3365,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OP_not_n (NOT, ivec4, 4, +); // 1 1101 OP_op_T (GE, u, uint, uivec2, uivec4, >=); - case OP_MUL_QV4_F: + case OP_QV4MUL_F: OPC(vec4) = qvmulf (OPA(vec4), OPB(vec4)); break; case OP_MOVE_I: @@ -3380,7 +3380,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) st->b * sizeof (pr_type_t)); break; OP_op_T (GE, U, ulong, ulvec2, ulvec4, >=); - case OP_MUL_QV4_D: + case OP_QV4MUL_D: OPC(dvec4) = qvmuld (OPA(dvec4), OPB(dvec4)); break; case OP_MEMSET_I: @@ -3394,12 +3394,12 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) break; // 1 1110 OP_op_T (LE, u, uint, uivec2, uivec4, <=); - case OP_MUL_V4Q_F: + case OP_V4QMUL_F: OPC(vec4) = vqmulf (OPA(vec4), OPB(vec4)); break; OP_op_T (LE, U, ulong, ulvec2, ulvec4, <=); - case OP_MUL_V4Q_D: + case OP_V4QMUL_D: OPC(dvec4) = vqmuld (OPA(dvec4), OPB(dvec4)); break; diff --git a/libs/gamecode/test/test-vector.c b/libs/gamecode/test/test-vector.c index 61d8852e9..814893f86 100644 --- a/libs/gamecode/test/test-vector.c +++ b/libs/gamecode/test/test-vector.c @@ -53,25 +53,25 @@ static pr_vec4_t float_globals_expect[] = { }; static dstatement_t float_vector_statements[] = { - { OP(0, 0, 0, OP_DOT_CC_F), 0, 2, 4 }, - { OP(0, 0, 0, OP_MUL_CC_F), 0, 2, 6 }, - { OP(0, 0, 0, OP_DOT_VV_F), 8, 12, 16 }, - { OP(0, 0, 0, OP_CROSS_VV_F), 8, 12, 20 }, - { OP(0, 0, 0, OP_DOT_QQ_F), 24, 28, 36 }, - { OP(0, 0, 0, OP_MUL_QQ_F), 24, 28, 40 }, - { OP(0, 0, 0, OP_MUL_QV_F), 24, 32, 44 }, - { OP(0, 0, 0, OP_MUL_VQ_F), 32, 24, 48 }, + { OP(0, 0, 0, OP_CDOT_F), 0, 2, 4 }, + { OP(0, 0, 0, OP_CMUL_F), 0, 2, 6 }, + { OP(0, 0, 0, OP_VDOT_F), 8, 12, 16 }, + { OP(0, 0, 0, OP_CROSS_F), 8, 12, 20 }, + { OP(0, 0, 0, OP_QDOT_F), 24, 28, 36 }, + { OP(0, 0, 0, OP_QMUL_F), 24, 28, 40 }, + { OP(0, 0, 0, OP_QVMUL_F), 24, 32, 44 }, + { OP(0, 0, 0, OP_VQMUL_F), 32, 24, 48 }, - { OP(0, 0, 0, OP_MUL_QQ_F), 24, 32, 52 }, + { OP(0, 0, 0, OP_QMUL_F), 24, 32, 52 }, { OP(0, 0, 0, OP_SWIZZLE_F), 24, 0x07e4, 60 }, - { OP(0, 0, 0, OP_MUL_QQ_F), 52, 60, 52 }, + { OP(0, 0, 0, OP_QMUL_F), 52, 60, 52 }, { OP(0, 0, 0, OP_SWIZZLE_F), 24, 0x07e4, 64 }, - { OP(0, 0, 0, OP_MUL_QQ_F), 64, 32, 56 }, - { OP(0, 0, 0, OP_MUL_QQ_F), 56, 24, 56 }, + { OP(0, 0, 0, OP_QMUL_F), 64, 32, 56 }, + { OP(0, 0, 0, OP_QMUL_F), 56, 24, 56 }, - { OP(0, 0, 0, OP_MUL_QV4_F), 24, 32, 68 }, - { OP(0, 0, 0, OP_MUL_V4Q_F), 32, 24, 72 }, + { OP(0, 0, 0, OP_QV4MUL_F), 24, 32, 68 }, + { OP(0, 0, 0, OP_V4QMUL_F), 32, 24, 72 }, }; static pr_dvec4_t double_globals_init[] = { @@ -127,25 +127,25 @@ static pr_dvec4_t double_globals_expect[] = { }; static dstatement_t double_vector_statements[] = { - { OP(0, 0, 0, OP_DOT_CC_D), 0, 4, 8 }, - { OP(0, 0, 0, OP_MUL_CC_D), 0, 4, 12 }, - { OP(0, 0, 0, OP_DOT_VV_D), 16, 24, 32 }, - { OP(0, 0, 0, OP_CROSS_VV_D), 16, 24, 40 }, - { OP(0, 0, 0, OP_DOT_QQ_D), 48, 56, 72 }, - { OP(0, 0, 0, OP_MUL_QQ_D), 48, 56, 80 }, - { OP(0, 0, 0, OP_MUL_QV_D), 48, 64, 88 }, - { OP(0, 0, 0, OP_MUL_VQ_D), 64, 48, 96 }, + { OP(0, 0, 0, OP_CDOT_D), 0, 4, 8 }, + { OP(0, 0, 0, OP_CMUL_D), 0, 4, 12 }, + { OP(0, 0, 0, OP_VDOT_D), 16, 24, 32 }, + { OP(0, 0, 0, OP_CROSS_D), 16, 24, 40 }, + { OP(0, 0, 0, OP_QDOT_D), 48, 56, 72 }, + { OP(0, 0, 0, OP_QMUL_D), 48, 56, 80 }, + { OP(0, 0, 0, OP_QVMUL_D), 48, 64, 88 }, + { OP(0, 0, 0, OP_VQMUL_D), 64, 48, 96 }, - { OP(0, 0, 0, OP_MUL_QQ_D), 48, 64, 104 }, + { OP(0, 0, 0, OP_QMUL_D), 48, 64, 104 }, { OP(0, 0, 0, OP_SWIZZLE_D), 48, 0x07e4, 120 }, - { OP(0, 0, 0, OP_MUL_QQ_D), 104, 120, 104 }, + { OP(0, 0, 0, OP_QMUL_D), 104, 120, 104 }, { OP(0, 0, 0, OP_SWIZZLE_D), 48, 0x07e4, 128 }, - { OP(0, 0, 0, OP_MUL_QQ_D), 128, 64, 112 }, - { OP(0, 0, 0, OP_MUL_QQ_D), 112, 48, 112 }, + { OP(0, 0, 0, OP_QMUL_D), 128, 64, 112 }, + { OP(0, 0, 0, OP_QMUL_D), 112, 48, 112 }, - { OP(0, 0, 0, OP_MUL_QV4_D), 48, 64, 136 }, - { OP(0, 0, 0, OP_MUL_V4Q_D), 64, 48, 144 }, + { OP(0, 0, 0, OP_QV4MUL_D), 48, 64, 136 }, + { OP(0, 0, 0, OP_V4QMUL_D), 64, 48, 144 }, }; test_t tests[] = { From 0b92cd3a884b7d4dba788760660bbf0aa5a0661f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 5 Jan 2022 19:09:07 +0900 Subject: [PATCH 041/360] [gamecode] Generate the new opcode table As I expect to be tweaking things for a while, it's part of the build process. This will make it a lot easier to adjust mnemonics and argument formats (tweaking the old table was a pain when conventions changed). It's not quite done as it still needs arg widths and types. --- .gitignore | 1 + Makefile.am | 6 + config.d/programs.m4 | 1 + include/QF/pr_comp.h | 11 + libs/gamecode/Makemodule.am | 13 + libs/gamecode/opcodes.py | 503 ++++++++++++++++++++++++++++++++++++ libs/gamecode/pr_opcode.c | 38 +++ 7 files changed, 573 insertions(+) create mode 100644 libs/gamecode/opcodes.py create mode 100644 libs/gamecode/pr_opcode.c diff --git a/.gitignore b/.gitignore index 25d1878ed..a3e375bd7 100644 --- a/.gitignore +++ b/.gitignore @@ -40,6 +40,7 @@ core /ltmain.sh /missing /mkinstalldirs +/py-compile /quakeforge-config /quakeforge.lsm /test-driver diff --git a/Makefile.am b/Makefile.am index dbc83cea2..33aa5b689 100644 --- a/Makefile.am +++ b/Makefile.am @@ -42,6 +42,7 @@ noinst_LTLIBRARIES = noinst_LIBRARIES = noinst_PROGRAMS = noinst_HEADERS = +noinst_PYTHON = plugin_LTLIBRARIES = RANLIB=touch @@ -110,6 +111,11 @@ qcautodep = $(join $(addsuffix $(DEPDIR)/,$(dir $(basename $(1)))),$(addsuffix . r_depfiles_remade= pas_depfiles_remade= +V_PY = $(V_PY_@AM_V@) +V_PY_ = $(V_PY_@AM_DEFAULT_V@) +V_PY_0 = @echo " PY " $@; +V_PY_1 = + V_GLSLANG = $(V_GLSLANG_@AM_V@) V_GLSLANG_ = $(V_GLSLANG_@AM_DEFAULT_V@) V_GLSLANG_0 = @echo " GLSLANG " $@; diff --git a/config.d/programs.m4 b/config.d/programs.m4 index bcff065c5..bb8ac5e9d 100644 --- a/config.d/programs.m4 +++ b/config.d/programs.m4 @@ -8,6 +8,7 @@ AC_PROG_CPP AC_PROG_LN_S AC_PROG_RANLIB AM_PROG_AS +AM_PATH_PYTHON([3]) PKG_PROG_PKG_CONFIG diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index 2785d6913..252bb0c18 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -619,6 +619,17 @@ typedef struct v6p_opcode_s { extern const v6p_opcode_t pr_v6p_opcodes[]; const v6p_opcode_t *PR_v6p_Opcode (pr_ushort_t opcode) __attribute__((const)); + +typedef struct opcode_s { + const char *opname; + const char *mnemonic; + int width; ///< number of components (1-4) + int size; ///< component size in words (1-2) + const char *fmt; +} opcode_t; +extern const opcode_t pr_opcodes[512]; +const opcode_t *PR_Opcode (pr_ushort_t opcode) __attribute__((const)); + void PR_Opcode_Init (void); // idempotent typedef struct dstatement_s { diff --git a/libs/gamecode/Makemodule.am b/libs/gamecode/Makemodule.am index af7a3d5a2..620edc7ee 100644 --- a/libs/gamecode/Makemodule.am +++ b/libs/gamecode/Makemodule.am @@ -13,9 +13,22 @@ libs_gamecode_libQFgamecode_la_SOURCES= \ libs/gamecode/pr_debug.c \ libs/gamecode/pr_exec.c \ libs/gamecode/pr_load.c \ + libs/gamecode/pr_opcode.c \ libs/gamecode/pr_parse.c \ libs/gamecode/pr_resolve.c \ libs/gamecode/pr_resource.c \ libs/gamecode/pr_strings.c \ libs/gamecode/pr_v6p_opcode.c \ libs/gamecode/pr_zone.c + +noinst_PYTHON += $(opcodes_py) + +opcodes_py = $(srcdir)/libs/gamecode/opcodes.py +pr_opcode_cinc = $(top_builddir)/libs/gamecode/pr_opcode.cinc +pr_opcode_src = \ + ${pr_opcode_cinc} +libs/gamecode/pr_opcode.lo: libs/gamecode/pr_opcode.c ${pr_opcode_src} + +$(pr_opcode_cinc): $(opcodes_py) + $(V_PY)$(PYTHON) $(opcodes_py) > $(pr_opcode_cinc).t && \ + $(am__mv) $(pr_opcode_cinc).t $(pr_opcode_cinc) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py new file mode 100644 index 000000000..105f37668 --- /dev/null +++ b/libs/gamecode/opcodes.py @@ -0,0 +1,503 @@ +bitmap_txt = """ +0 0000 mmss load +0 0001 mmss store +0 0010 mmss push +0 0011 mmss pop +0 0100 ccmm branch +0 0101 0nnn rcall 1-8 (0 0100 11mm with 0 params for [r]call0) +0 0101 10ss return +0 0101 1100 returnv +0 0101 1101 with (reg encoded in st->c) +0 0101 111t state +0 0110 ccmm branch2 +0 0111 tooo vecops +0 1ccc ttss compare +1 0ooo ttss mathops +1 011r tuss shiftops +1 0110 o1oo string +1 1ccc t0ss compare2 +1 1000 ooss bitops +1 1001 t1ss scale +1 1001 t100 swizzle +1 1010 d1xx convert +1 1011 00mm lea +1 1011 01ss any +1 1011 0100 lea_e +1 1011 10ss all +1 1011 1000 pushregs +1 1011 11ss none +1 1011 1100 popregs +1 1101 01oo move +1 1101 11oo memset +1 1110 d1xx convert2 +1 11dd t100 vecops2 +1 1100 ooss boolops +n 1111 nnnn +0 1011 nnnn +""" + +branch_fmt=[ + "branch %sa (%Ob)", + "*%Ga", + "%Ga[%sb]", + "%Ga[%Gb]", +] +compare_ccc=[ "eq", "lt", "gt", None, "ne", "ge", "le", None] +type_tt=['I', 'F', 'L', 'D'] +all_formats = { + "opcode": "OP_ALL_{ss+1}", + "mnemonic": "all", + "opname": "all", + "format": "%Ga, %gc", +} +any_formats = { + "opcode": "OP_ANY_{ss+1}", + "mnemonic": "any", + "opname": "any", + "format": "%Ga, %gc", +} +bitops_formats = { + "opcode": "OP_{op_bit[oo].upper()}_I_{ss+1}", + "mnemonic": "{op_bit[oo]}", + "opname": "{op_bit[oo]}", + "format": "{bit_fmt[oo]}", + "args": { + "op_bit":["bitand", "bitor", "bitxor", "bitnot"], + "bit_fmt": [ + "%Ga, %Gb, %gc", + "%Ga, %Gb, %gc", + "%Ga, %Gb, %gc", + "%Ga, %gc", + ], + }, +} +boolops_formats = { + "opcode": "OP_{op_bool[oo].upper()}_I_{ss+1}", + "mnemonic": "{op_bool[oo]}", + "opname": "{op_bool[oo]}", + "format": "{bool_fmt[oo]}", + "args": { + "op_bool":["and", "or", "xor", "not"], + "bool_fmt": [ + "%Ga, %Gb, %gc", + "%Ga, %Gb, %gc", + "%Ga, %Gb, %gc", + "%Ga, %gc", + ], + }, +} +branch_formats = { + "opcode": "OP_{op_cond[cc].upper()}_{op_mode[mm]}", + "mnemonic": "{op_cond[cc]}", + "opname": "{op_cond[cc]}", + "format": "{cond_fmt[cc]}{branch_fmt[mm]}", + "args": { + "op_mode": "ABCD", + "op_cond": ["ifnot", "if", "jump", "call"], + "branch_fmt": branch_fmt, + "cond_fmt": ["%Gc ", "%Gc ", "", ""], + }, +} +branch2_formats = { + "opcode": "OP_{op_cond[cc].upper()}_{op_mode[mm]}", + "mnemonic": "{op_cond[cc]}", + "opname": "{op_cond[cc]}", + "format": "%Gc {branch_fmt[mm]}", + "args": { + "op_mode": "ABCD", + "op_cond": ["ifa", "ifbe", "ifb", "ifae"], + "branch_fmt": branch_fmt, + }, +} +compare_formats = { + "opcode": "OP_{op_cmp[ccc].upper()}_{cmp_type[tt]}_{ss+1}", + "mnemonic": "{op_cmp[ccc]}.{cmp_type[tt]}", + "opname": "{op_cmp[ccc]}", + "args": { + "op_cmp": compare_ccc, + "cmp_type":type_tt, + }, +} +compare2_formats = { + "opcode": "OP_{op_cmp[ccc].upper()}_{cmp_type[t]}_{ss+1}", + "mnemonic": "{op_cmp[ccc]}.{cmp_type[t]}", + "opname": "{op_cmp[ccc]}", + "args": { + "op_cmp": compare_ccc, + "cmp_type":['u', 'U'], + }, +} +convert_formats = { + "opcode": "OP_CONV_{op_conv[d*4+xx]}", + "mnemonic": "conv.{op_conv[d*4+xx]}", + "opname": "conv", + "format": "%Ga %gc", + "args": { + "op_conv": ["IF", "LD", "uF", "UD", "FI", "DL", "Fu", "DU"], + }, +} +lea_formats = { + "opcode": "OP_LEA_{op_mode[mm]}", + "mnemonic": "lea", + "opname": "lea", + "format": "{lea_fmt[mm]}", + "args": { + "op_mode": "ABCD", + "lea_fmt": [ + "%ga, %gc", + "*%Ga, %gc", + "*(%Ga + %sb), %gc", + "*(%Ga + %Gb), %gc", + ], + }, +} +lea_e_formats = { + "opcode": "OP_LEA_E", + "mnemonic": "lea", + "opname": "lea", + "format": "%Ga.%Gb(%Ec), %gc", +} +load_formats = { + "opcode": "OP_LOAD_{op_mode[mm]}_{ss+1}", + "mnemonic": "load", + "opname": "load", + "format": "{load_fmt[mm]}", + "args": { + "op_mode": "EBCD", + "load_fmt": [ + "%Ga.%Gb(%Ex), %gc", + "*%Ga, %gc", + "*(%Ga + %sb), %gc", + "*(%Ga + %Gb), %gc", + ], + }, +} +mathops_formats = { + "opcode": "OP_{op_math[ooo].upper()}_{math_type[tt]}_{ss+1}", + "mnemonic": "{op_math[ooo]}.{math_type[tt]}", + "opname": "{op_math[ooo]}", + "args": { + "op_math": ["mul", "div", "rem", "mod", "add", "sub", None, None], + "math_type":type_tt, + }, +} +memset_formats = { + "opcode": "OP_MEMSET_{op_memset[oo].upper()}", + "mnemonic": "memset.{op_memset[oo]}", + "opname": "memset", + "format": "{memset_fmt[oo]}", + "args": { + "op_memset": [None, "i", "p", "pi"], + "memset_fmt": [None, "%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc"], + }, +} +move_formats = { + "opcode": "OP_MOVE_{op_move[oo].upper()}", + "mnemonic": "memset.{op_move[oo]}", + "opname": "memset", + "format": "{move_fmt[oo]}", + "args": { + "op_move": [None, "i", "p", "pi"], + "move_fmt": [None, "%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc"], + }, +} +none_formats = { + "opcode": "OP_NONE_{ss+1}", + "mnemonic": "none", + "opname": "none", + "format": "%Ga, %gc", +} +push_formats = { + "opcode": "OP_PUSH_{op_mode[mm]}_{ss+1}", + "mnemonic": "push", + "opname": "push", + "format": "{push_fmt[mm]}", + "args": { + "op_mode": "ABCD", + "push_fmt": [ + "%Ga", + "*%Ga", + "*(%Ga + %sb)", + "*(%Ga + %Gb)", + ], + }, +} +pushregs_formats = { + "opcode": "OP_PUSHREGS", + "mnemonic": "pushregs", + "opname": "pushregs", + "format": None, +} +pop_formats = { + "opcode": "OP_POP_{op_mode[mm]}_{ss+1}", + "mnemonic": "pop", + "opname": "pop", + "format": "{pop_fmt[mm]}", + "args": { + "op_mode": "ABCD", + "pop_fmt": [ + "%ga", + "*%Ga", + "*(%Ga + %sb)", + "*(%Ga + %Gb)", + ], + }, +} +popregs_formats = { + "opcode": "OP_POPREGS", + "mnemonic": "popregs", + "opname": "popregs", + "format": None, +} +scale_formats = { + "opcode": "OP_SCALE_{scale_type[t]}_{ss+1}", + "mnemonic": "scale.{scale_type[t]}", + "opname": "scale", + "args": { + "scale_type":['F', 'D'], + }, +} +shiftops_formats = { + "opcode": "OP_{op_shift[u*2+r].upper()}_{shift_type[u*2+t]}_{ss+1}", + "mnemonic": "{op_shift[u*2+r]}.{shift_type[u*2+t]}", + "opname": "{op_shift[u*2+r]}", + "args": { + "op_shift": ["shl", "asr", "shl", "shr"], + "shift_type":['I', 'L', 'u', 'U'], + }, +} +state_formats = { + "opcode": "OP_STATE_{state[t]}", + "mnemonic": "state.{state[t]}", + "opname": "state", + "format": "{state_fmt[t]}", + "args": { + "state": ["ft", "ftt"], + "state_fmt": ["%Ga, %Gb", "%Ga, %Gb, %Gc"], + }, +} +store_formats = { + "opcode": "OP_STORE_{op_mode[mm]}_{ss+1}", + "mnemonic": "store", + "opname": "store", + "format": "{store_fmt[mm]}", + "args": { + "op_mode": "ABCD", + "store_fmt": [ + "%Gc, %ga", + "%Gc, *%Ga", + "%Gc, *(%Ga + %sb)", + "%Gc, *(%Ga + %Gb)", + ], + }, +} +string_formats = { + "opcode": "OP_{op_str[o*4+oo].upper()}_S", + "mnemonic": "{op_str[o*4+oo]}.s", + "opname": "{op_str[o*4+oo]}", + "format": "{str_fmt[o*4+oo]}", + "args": { + "op_str": ["eq", "lt", "gt", "add", "cmp", "ge", "le", "not"], + "str_fmt": [ + "%Ga, %Gb, %gc", + "%Ga, %Gb, %gc", + "%Ga, %Gb, %gc", + "%Ga, %Gb, %gc", + "%Ga, %Gb, %gc", + "%Ga, %Gb, %gc", + "%Ga, %Gb, %gc", + "%Ga, %gc", + ], + }, +} +swizzle_formats = { + "opcode": "OP_SWIZZLE_{swiz_type[t]}", + "mnemonic": "swizzle.{swiz_type[t]}", + "opname": "swizzle", + "format": "%Ga %sb %gc", + "args": { + "swiz_type":['F', 'D'], + }, +} +rcall_formats = { + "opcode": "OP_CALL_{nnn+1}", + "mnemonic": "rcall{nnn+1}", + "opname": "rcall{nnn+1}", + "format": "{rcall_fmt[nnn]}", + "args": { + "rcall_fmt": [ + "%Fa (%P0b)", + "%Fa (%P0b, %P1c)", + "%Fa (%P0b, %P1c, %P2x)", + "%Fa (%P0b, %P1c, %P2x, %P3x)", + "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x)", + "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x)", + "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x)", + "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x, %P7x)", + ], + }, +} +return_formats = { + "opcode": "OP_RETURN_{ss+1}", + "mnemonic": "return{ss+1}", + "opname": "return{ss+1}", + "format": "%Ra", +} +returnv_formats = { + "opcode": "OP_RETURN_0", + "mnemonic": "return", + "opname": "return", + "format": None, +} +vecops_formats = { + "opcode": "OP_{op_vop[ooo].upper()}_{vop_type[t]}", + "mnemonic": "{op_vop[ooo]}.{vop_type[t]}", + "opname": "{op_vop[ooo]}", + "args": { + "op_vop": ["cdot", "vdot", "qdot", "cross", + "cmul", "qvmul", "vqmul", "qmul"], + "vop_type": ['F', 'D'], + }, +} +vecops2_formats = { + "opcode": "OP_{op_vop[dd].upper()}_{vop_type[t]}", + "mnemonic": "{op_vop[dd]}.{vop_type[t]}", + "opname": "{op_vop[dd]}", + "args": { + "op_vop": [None, "qv4mul", "v4qmul", None], + "vop_type": ['F', 'D'], + }, +} +with_formats = { + "opcode": "OP_WITH", + "mnemonic": "with", + "opname": "with", + "format": "%sa, %sb, $sc", +} + +group_map = { + "all": all_formats, + "any": any_formats, + "bitops": bitops_formats, + "boolops": boolops_formats, + "branch": branch_formats, + "branch2": branch2_formats, + "compare": compare_formats, + "compare2": compare2_formats, + "convert": convert_formats, + "convert2": convert_formats, + "lea": lea_formats, + "lea_e": lea_e_formats, + "load": load_formats, + "mathops": mathops_formats, + "memset": memset_formats, + "move": move_formats, + "none": none_formats, + "push": push_formats, + "pushregs": pushregs_formats, + "pop": pop_formats, + "popregs": popregs_formats, + "scale": scale_formats, + "shiftops": shiftops_formats, + "state": state_formats, + "store": store_formats, + "string": string_formats, + "swizzle": swizzle_formats, + "rcall": rcall_formats, + "return": return_formats, + "returnv": returnv_formats, + "vecops": vecops_formats, + "vecops2": vecops2_formats, + "with": with_formats, +} + +def parse_bits(bit_string): + bits = [""] + isbit = bit_string[0] in ['0', '1'] + lastbit = bit_string[0] + while bit_string: + bit = bit_string[0] + bit_string = bit_string[1:] + if isbit and bit in ['0', '1']: + bits[-1] = bits[-1] + bit + elif lastbit == bit: + bits[-1] = bits[-1] + bit + else: + bits.append(bit) + lastbit = bit + isbit = bit in ['0', '1'] + return bits + +opcodes = [None] * 512 + +def expand_opcodes(bits, group, num=0): + if not bits: + opcodes[num] = group + return + block = bits[0] + bits = bits[1:] + num <<= len(block) + if block[0] in ['0', '1']: + num |= int(block, 2) + expand_opcodes(bits, group, num) + else: + for n in range(1< + + Author: Bill Currie + Date: 2022/1/4 + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + +*/ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "QF/progs.h" + +const opcode_t pr_opcodes[512] = { +#include "libs/gamecode/pr_opcode.cinc" +}; From c9b2a740a0233903a0909b04da0c82e245af6b6a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 5 Jan 2022 22:32:07 +0900 Subject: [PATCH 042/360] [gamecode] Add etypes for long and ulong And partial implementations in qfcc (most places will generate an internal error (not implemented) or segfault, but some low-hanging fruit has already been implemented). --- include/QF/pr_comp.h | 2 ++ include/QF/progs.h | 2 ++ libs/gamecode/pr_debug.c | 31 +++++++++++++++++++++++++++++++ nq/source/sv_progs.c | 6 +++++- qw/source/sv_progs.c | 6 +++++- tools/qfcc/include/expr.h | 2 ++ tools/qfcc/source/constfold.c | 30 ++++++++++++++++++++++++++++++ tools/qfcc/source/dot_expr.c | 7 +++++++ tools/qfcc/source/expr.c | 9 +++++++++ tools/qfcc/source/expr_bool.c | 3 +++ tools/qfcc/source/statements.c | 11 +++++++++++ tools/qfcc/source/type.c | 14 ++++++++++++++ 12 files changed, 121 insertions(+), 2 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index 252bb0c18..abaa4160d 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -67,6 +67,8 @@ typedef enum { ev_uinteger, ev_short, // value is embedded in the opcode ev_double, + ev_long, + ev_ulong, ev_invalid, // invalid type. used for instruction checking ev_type_count // not a type, gives number of types diff --git a/include/QF/progs.h b/include/QF/progs.h index 6f3866ee1..c4b2ef070 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1733,6 +1733,8 @@ typedef struct type_view_s { type_view_func uinteger_view; type_view_func short_view; type_view_func double_view; + type_view_func long_view; + type_view_func ulong_view; type_view_func struct_view; type_view_func union_view; diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 9b8d11fde..7e3090a76 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -42,6 +42,7 @@ #include #include #include +#include #include "QF/fbsearch.h" #include "QF/cvar.h" @@ -143,6 +144,10 @@ static void pr_debug_short_view (qfot_type_t *type, pr_type_t *value, void *_data); static void pr_debug_double_view (qfot_type_t *type, pr_type_t *value, void *_data); +static void pr_debug_long_view (qfot_type_t *type, pr_type_t *value, + void *_data); +static void pr_debug_ulong_view (qfot_type_t *type, pr_type_t *value, + void *_data); static void pr_debug_struct_view (qfot_type_t *type, pr_type_t *value, void *_data); static void pr_debug_union_view (qfot_type_t *type, pr_type_t *value, @@ -168,6 +173,8 @@ static type_view_t raw_type_view = { pr_debug_uinteger_view, pr_debug_short_view, pr_debug_double_view, + pr_debug_long_view, + pr_debug_ulong_view, pr_debug_struct_view, pr_debug_union_view, pr_debug_enum_view, @@ -1060,6 +1067,12 @@ value_string (pr_debug_data_t *data, qfot_type_t *type, pr_type_t *value) case ev_double: raw_type_view.double_view (type, value, data); break; + case ev_long: + raw_type_view.long_view (type, value, data); + break; + case ev_ulong: + raw_type_view.ulong_view (type, value, data); + break; case ev_invalid: case ev_type_count: dstring_appendstr (data->dstr, ""); @@ -1363,6 +1376,24 @@ pr_debug_double_view (qfot_type_t *type, pr_type_t *value, void *_data) dasprintf (dstr, "%.17g", *(double *)value); } +static void +pr_debug_long_view (qfot_type_t *type, pr_type_t *value, void *_data) +{ + __auto_type data = (pr_debug_data_t *) _data; + dstring_t *dstr = data->dstr; + + dasprintf (dstr, "%" PRIi64, *(int64_t *)value); +} + +static void +pr_debug_ulong_view (qfot_type_t *type, pr_type_t *value, void *_data) +{ + __auto_type data = (pr_debug_data_t *) _data; + dstring_t *dstr = data->dstr; + + dasprintf (dstr, "%" PRIu64, *(uint64_t *)value); +} + static void pr_dump_struct (qfot_type_t *type, pr_type_t *value, void *_data, const char *struct_type) diff --git a/nq/source/sv_progs.c b/nq/source/sv_progs.c index 58f79bc7e..2c9d82836 100644 --- a/nq/source/sv_progs.c +++ b/nq/source/sv_progs.c @@ -357,7 +357,11 @@ set_address (sv_def_t *def, void *address) case ev_pointer: case ev_integer: case ev_uinteger: - *(int **)def->field = (int *) address; + *(pr_int_t **)def->field = (pr_int_t *) address; + break; + case ev_long: + case ev_ulong: + *(pr_long_t **)def->field = (pr_long_t *) address; break; } } diff --git a/qw/source/sv_progs.c b/qw/source/sv_progs.c index 84873b352..93f6042a0 100644 --- a/qw/source/sv_progs.c +++ b/qw/source/sv_progs.c @@ -390,7 +390,11 @@ set_address (sv_def_t *def, void *address) case ev_pointer: case ev_integer: case ev_uinteger: - *(int **)def->field = (int *) address; + *(pr_int_t **)def->field = (pr_int_t *) address; + break; + case ev_long: + case ev_ulong: + *(pr_long_t **)def->field = (pr_long_t *) address; break; } } diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 6b8fa8034..5d05f2a40 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -209,6 +209,8 @@ typedef struct ex_value_s { union { const char *string_val; ///< string constant double double_val; ///< double constant + int64_t long_val; ///< signed 64-bit constant + uint64_t ulong_val; ///< unsigned 64-bit constant float float_val; ///< float constant float vector_val[3]; ///< vector constant int entity_val; ///< entity constant diff --git a/tools/qfcc/source/constfold.c b/tools/qfcc/source/constfold.c index 2d2c1400d..2459b392f 100644 --- a/tools/qfcc/source/constfold.c +++ b/tools/qfcc/source/constfold.c @@ -1104,6 +1104,8 @@ static operation_t op_void[ev_type_count] = { do_op_invalid, // ev_uinteger do_op_invalid, // ev_short do_op_invalid, // ev_double + 0, // ev_long + 0, // ev_ulong do_op_invalid, // ev_invalid }; @@ -1121,6 +1123,8 @@ static operation_t op_string[ev_type_count] = { do_op_invalid, // ev_uinteger do_op_invalid, // ev_short do_op_invalid, // ev_double + 0, // ev_long + 0, // ev_ulong do_op_invalid, // ev_invalid }; @@ -1138,6 +1142,8 @@ static operation_t op_float[ev_type_count] = { do_op_float, // ev_uinteger do_op_float, // ev_short do_op_double, // ev_double + 0, // ev_long + 0, // ev_ulong do_op_invalid, // ev_invalid }; @@ -1155,6 +1161,8 @@ static operation_t op_vector[ev_type_count] = { do_op_vector, // ev_uinteger do_op_vector, // ev_short do_op_vector, // ev_double + 0, // ev_long + 0, // ev_ulong do_op_invalid, // ev_invalid }; @@ -1172,6 +1180,8 @@ static operation_t op_entity[ev_type_count] = { do_op_invalid, // ev_uinteger do_op_invalid, // ev_short do_op_invalid, // ev_double + 0, // ev_long + 0, // ev_ulong do_op_invalid, // ev_invalid }; @@ -1189,6 +1199,8 @@ static operation_t op_field[ev_type_count] = { do_op_invalid, // ev_uinteger do_op_invalid, // ev_short do_op_invalid, // ev_double + 0, // ev_long + 0, // ev_ulong do_op_invalid, // ev_invalid }; @@ -1206,6 +1218,8 @@ static operation_t op_func[ev_type_count] = { do_op_func, // ev_uinteger do_op_func, // ev_short do_op_func, // ev_double + 0, // ev_long + 0, // ev_ulong do_op_func, // ev_invalid }; @@ -1223,6 +1237,8 @@ static operation_t op_pointer[ev_type_count] = { do_op_pointer, // ev_uinteger do_op_pointer, // ev_short do_op_pointer, // ev_double + 0, // ev_long + 0, // ev_ulong do_op_pointer, // ev_invalid }; @@ -1240,6 +1256,8 @@ static operation_t op_quaternion[ev_type_count] = { do_op_quaternion, // ev_uinteger do_op_quaternion, // ev_short do_op_quaternion, // ev_double + 0, // ev_long + 0, // ev_ulong do_op_invalid, // ev_invalid }; @@ -1257,6 +1275,8 @@ static operation_t op_integer[ev_type_count] = { do_op_uinteger, // ev_uinteger do_op_integer, // ev_short do_op_double, // ev_double + 0, // ev_long + 0, // ev_ulong do_op_invalid, // ev_invalid }; @@ -1274,6 +1294,8 @@ static operation_t op_uinteger[ev_type_count] = { do_op_uinteger, // ev_uinteger do_op_uinteger, // ev_short do_op_double, // ev_double + 0, // ev_long + 0, // ev_ulong do_op_invalid, // ev_invalid }; @@ -1291,6 +1313,8 @@ static operation_t op_short[ev_type_count] = { do_op_uinteger, // ev_uinteger do_op_short, // ev_short do_op_double, // ev_double + 0, // ev_long + 0, // ev_ulong do_op_invalid, // ev_invalid }; @@ -1308,6 +1332,8 @@ static operation_t op_double[ev_type_count] = { do_op_uinteger, // ev_uinteger do_op_short, // ev_short do_op_double, // ev_double + 0, // ev_long + 0, // ev_ulong do_op_invalid, // ev_invalid }; @@ -1325,6 +1351,8 @@ static operation_t op_compound[ev_type_count] = { do_op_compound, // ev_uinteger do_op_compound, // ev_short do_op_compound, // ev_double + do_op_compound, // ev_long + do_op_compound, // ev_ulong do_op_compound, // ev_invalid }; @@ -1342,6 +1370,8 @@ static operation_t *do_op[ev_type_count] = { op_uinteger, // ev_uinteger op_short, // ev_short op_double, // ev_double + 0, // ev_long + 0, // ev_ulong op_compound, // ev_invalid }; diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index cde32c8fd..edd1739a9 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -38,6 +38,7 @@ # include #endif #include +#include #include #include @@ -518,6 +519,12 @@ print_value (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) case ev_uinteger: label = va (0, "u %u", e->e.value->v.uinteger_val); break; + case ev_long: + label = va (0, "i %"PRIi64, e->e.value->v.long_val); + break; + case ev_ulong: + label = va (0, "u %"PRIu64, e->e.value->v.ulong_val); + break; case ev_short: label = va (0, "s %d", e->e.value->v.short_val); break; diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 26d892c60..d4f36d306 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1633,6 +1633,9 @@ unary_expr (int op, expr_t *e) case ev_quat: QuatNegate (expr_vector (e), q); return new_vector_expr (q); + case ev_long: + case ev_ulong: + internal_error (e, "long not implemented"); case ev_integer: return new_integer_expr (-expr_integer (e)); case ev_uinteger: @@ -1725,6 +1728,9 @@ unary_expr (int op, expr_t *e) return new_integer_expr (!VectorIsZero (expr_vector (e))); case ev_quat: return new_integer_expr (!QuatIsZero (expr_quaternion (e))); + case ev_long: + case ev_ulong: + internal_error (e, "long not implemented"); case ev_integer: return new_integer_expr (!expr_integer (e)); case ev_uinteger: @@ -1791,6 +1797,9 @@ unary_expr (int op, expr_t *e) case ev_quat: QuatConj (expr_vector (e), q); return new_vector_expr (q); + case ev_long: + case ev_ulong: + internal_error (e, "long not implemented"); case ev_integer: return new_integer_expr (~expr_integer (e)); case ev_uinteger: diff --git a/tools/qfcc/source/expr_bool.c b/tools/qfcc/source/expr_bool.c index fd21de053..83c202692 100644 --- a/tools/qfcc/source/expr_bool.c +++ b/tools/qfcc/source/expr_bool.c @@ -94,6 +94,9 @@ test_expr (expr_t *e) return new_alias_expr (type_default, e); new = new_string_expr (0); break; + case ev_long: + case ev_ulong: + internal_error (e, "long not implemented"); case ev_uinteger: case ev_integer: case ev_short: diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index ecd759818..0dfcebe88 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -38,6 +38,7 @@ #endif #include +#include #include "qfalloca.h" @@ -161,6 +162,10 @@ operand_string (operand_t *op) return va (0, "int %d", op->value->v.integer_val); case ev_uinteger: return va (0, "uint %u", op->value->v.uinteger_val); + case ev_long: + return va (0, "long %"PRIi64, op->value->v.long_val); + case ev_ulong: + return va (0, "ulong %"PRIu64, op->value->v.ulong_val); case ev_short: return va (0, "short %d", op->value->v.short_val); case ev_void: @@ -238,6 +243,12 @@ _print_operand (operand_t *op) case ev_uinteger: printf ("%u", op->value->v.uinteger_val); break; + case ev_long: + printf ("%"PRIu64, op->value->v.long_val); + break; + case ev_ulong: + printf ("%"PRIu64, op->value->v.ulong_val); + break; case ev_short: printf ("%d", op->value->v.short_val); break; diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index bccf431b7..17dd74571 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -188,6 +188,8 @@ free_type (type_t *type) case ev_quat: case ev_integer: case ev_uinteger: + case ev_long: + case ev_ulong: case ev_short: case ev_double: break; @@ -228,6 +230,8 @@ copy_chain (type_t *type, type_t *append) case ev_quat: case ev_integer: case ev_uinteger: + case ev_long: + case ev_ulong: case ev_short: case ev_double: internal_error (0, "copy basic type"); @@ -279,6 +283,8 @@ append_type (type_t *type, type_t *new) case ev_quat: case ev_integer: case ev_uinteger: + case ev_long: + case ev_ulong: case ev_short: case ev_double: internal_error (0, "append to basic type"); @@ -656,6 +662,8 @@ print_type_str (dstring_t *str, const type_t *type) case ev_quat: case ev_integer: case ev_uinteger: + case ev_long: + case ev_ulong: case ev_short: case ev_double: dasprintf (str, " %s", pr_type_name[type->type]); @@ -820,6 +828,12 @@ encode_type (dstring_t *encoding, const type_t *type) case ev_uinteger: dasprintf (encoding, "I"); return; + case ev_long: + dasprintf (encoding, "l"); + return; + case ev_ulong: + dasprintf (encoding, "L"); + return; case ev_short: dasprintf (encoding, "s"); return; From c74cfb9bf6953b5c85ef56d1eede603d332e2970 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 5 Jan 2022 22:33:59 +0900 Subject: [PATCH 043/360] [gamecode] Generate instruction widths and types Not everything is correct, but this is enough to get started on supporting disassembly in the various tools and code generation in qfcc. --- include/QF/pr_comp.h | 4 +- libs/gamecode/opcodes.py | 131 +++++++++++++++++++++++++++++++++++++-- 2 files changed, 128 insertions(+), 7 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index abaa4160d..26f0f07e3 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -625,8 +625,8 @@ const v6p_opcode_t *PR_v6p_Opcode (pr_ushort_t opcode) __attribute__((const)); typedef struct opcode_s { const char *opname; const char *mnemonic; - int width; ///< number of components (1-4) - int size; ///< component size in words (1-2) + int widths[3]; ///< component count for each argument (1-4) + etype_t types[3]; ///< component type for each argument const char *fmt; } opcode_t; extern const opcode_t pr_opcodes[512]; diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 105f37668..dbb315009 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -42,25 +42,34 @@ branch_fmt=[ "%Ga[%sb]", "%Ga[%Gb]", ] -compare_ccc=[ "eq", "lt", "gt", None, "ne", "ge", "le", None] -type_tt=['I', 'F', 'L', 'D'] +compare_ccc = [ "eq", "lt", "gt", None, "ne", "ge", "le", None] +type_tt = ['I', 'F', 'L', 'D'] +etype_tt = ["ev_integer", "ev_float", "ev_long", "ev_double"] +unsigned_t = ["ev_uinteger", "ev_ulong"] +float_t = ["ev_float", "ev_double"] all_formats = { "opcode": "OP_ALL_{ss+1}", "mnemonic": "all", "opname": "all", "format": "%Ga, %gc", + "widths": "{ss+1}, 0, 1", + "types": "ev_integer, ev_integer, ev_integer", } any_formats = { "opcode": "OP_ANY_{ss+1}", "mnemonic": "any", "opname": "any", "format": "%Ga, %gc", + "widths": "{ss+1}, 0, 1", + "types": "ev_integer, ev_integer, ev_integer", } bitops_formats = { "opcode": "OP_{op_bit[oo].upper()}_I_{ss+1}", "mnemonic": "{op_bit[oo]}", "opname": "{op_bit[oo]}", "format": "{bit_fmt[oo]}", + "widths": "{ss+1}, {ss+1}, {ss+1}", + "types": "ev_integer, ev_integer, ev_integer", "args": { "op_bit":["bitand", "bitor", "bitxor", "bitnot"], "bit_fmt": [ @@ -76,6 +85,8 @@ boolops_formats = { "mnemonic": "{op_bool[oo]}", "opname": "{op_bool[oo]}", "format": "{bool_fmt[oo]}", + "widths": "{ss+1}, {ss+1}, {ss+1}", + "types": "ev_integer, ev_integer, ev_integer", "args": { "op_bool":["and", "or", "xor", "not"], "bool_fmt": [ @@ -91,11 +102,19 @@ branch_formats = { "mnemonic": "{op_cond[cc]}", "opname": "{op_cond[cc]}", "format": "{cond_fmt[cc]}{branch_fmt[mm]}", + "widths": "{cond_widths[cc]}", + "types": "ev_void, ev_void, ev_integer", "args": { "op_mode": "ABCD", "op_cond": ["ifnot", "if", "jump", "call"], "branch_fmt": branch_fmt, "cond_fmt": ["%Gc ", "%Gc ", "", ""], + "cond_widths": [ + "0, 0, 1", + "0, 0, 1", + "0, 0, 0", + "0, 0, 0", + ], }, } branch2_formats = { @@ -103,28 +122,42 @@ branch2_formats = { "mnemonic": "{op_cond[cc]}", "opname": "{op_cond[cc]}", "format": "%Gc {branch_fmt[mm]}", + "widths": "{cond_widths[cc]}", + "types": "ev_void, ev_void, ev_integer", "args": { "op_mode": "ABCD", "op_cond": ["ifa", "ifbe", "ifb", "ifae"], "branch_fmt": branch_fmt, + "cond_widths": [ + "0, 0, 1", + "0, 0, 1", + "0, 0, 1", + "0, 0, 1", + ], }, } compare_formats = { "opcode": "OP_{op_cmp[ccc].upper()}_{cmp_type[tt]}_{ss+1}", "mnemonic": "{op_cmp[ccc]}.{cmp_type[tt]}", "opname": "{op_cmp[ccc]}", + "widths": "{ss+1}, {ss+1}, {ss+1}", + "types": "{cmp_types[tt]}, {cmp_types[tt]}, ev_integer", "args": { "op_cmp": compare_ccc, "cmp_type":type_tt, + "cmp_types":etype_tt, }, } compare2_formats = { "opcode": "OP_{op_cmp[ccc].upper()}_{cmp_type[t]}_{ss+1}", "mnemonic": "{op_cmp[ccc]}.{cmp_type[t]}", "opname": "{op_cmp[ccc]}", + "widths": "{ss+1}, {ss+1}, {ss+1}", + "types": "{cmp_types[t]}, {cmp_types[t]}, ev_integer", "args": { "op_cmp": compare_ccc, "cmp_type":['u', 'U'], + "cmp_types":unsigned_t, }, } convert_formats = { @@ -132,8 +165,16 @@ convert_formats = { "mnemonic": "conv.{op_conv[d*4+xx]}", "opname": "conv", "format": "%Ga %gc", + "widths": "1, 0, 1", + "types": "{cnv_types[xx][d]}, ev_invalid, {cnv_types[xx][1-d]}", "args": { "op_conv": ["IF", "LD", "uF", "UD", "FI", "DL", "Fu", "DU"], + "cnv_types": [ + ["ev_integer", "ev_float"], + ["ev_long", "ev_double"], + ["ev_uinteger", "ev_float"], + ["ev_ulong", "ev_double"], + ], }, } lea_formats = { @@ -141,6 +182,8 @@ lea_formats = { "mnemonic": "lea", "opname": "lea", "format": "{lea_fmt[mm]}", + "widths": "0, 0, 1", + "types": "ev_pointer, ev_pointer, ev_pointer", "args": { "op_mode": "ABCD", "lea_fmt": [ @@ -156,12 +199,16 @@ lea_e_formats = { "mnemonic": "lea", "opname": "lea", "format": "%Ga.%Gb(%Ec), %gc", + "types": "ev_entity, ev_field, ev_pointer", + "widths": "0, 0, 1", } load_formats = { "opcode": "OP_LOAD_{op_mode[mm]}_{ss+1}", "mnemonic": "load", "opname": "load", "format": "{load_fmt[mm]}", + "widths": "0, 0, {ss+1}", + "types": "ev_void, ev_void, ev_void", "args": { "op_mode": "EBCD", "load_fmt": [ @@ -176,9 +223,12 @@ mathops_formats = { "opcode": "OP_{op_math[ooo].upper()}_{math_type[tt]}_{ss+1}", "mnemonic": "{op_math[ooo]}.{math_type[tt]}", "opname": "{op_math[ooo]}", + "widths": "{ss+1}, {ss+1}, {ss+1}", + "types": "{math_types[tt]}, {math_types[tt]}, {math_types[tt]}", "args": { "op_math": ["mul", "div", "rem", "mod", "add", "sub", None, None], "math_type":type_tt, + "math_types": etype_tt, }, } memset_formats = { @@ -186,6 +236,8 @@ memset_formats = { "mnemonic": "memset.{op_memset[oo]}", "opname": "memset", "format": "{memset_fmt[oo]}", + "widths": "0, 0, 0", + "types": "ev_integer, ev_void, ev_void", "args": { "op_memset": [None, "i", "p", "pi"], "memset_fmt": [None, "%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc"], @@ -196,6 +248,8 @@ move_formats = { "mnemonic": "memset.{op_move[oo]}", "opname": "memset", "format": "{move_fmt[oo]}", + "widths": "0, 0, 0", + "types": "ev_integer, ev_void, ev_void", "args": { "op_move": [None, "i", "p", "pi"], "move_fmt": [None, "%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc"], @@ -206,12 +260,16 @@ none_formats = { "mnemonic": "none", "opname": "none", "format": "%Ga, %gc", + "widths": "{ss+1}, 0, 1", + "types": "ev_integer, ev_invalid, ev_integer", } push_formats = { "opcode": "OP_PUSH_{op_mode[mm]}_{ss+1}", "mnemonic": "push", "opname": "push", "format": "{push_fmt[mm]}", + "widths": "{ss+1}, 0, 0", + "types": "ev_void, ev_void, ev_invalid", "args": { "op_mode": "ABCD", "push_fmt": [ @@ -226,6 +284,8 @@ pushregs_formats = { "opcode": "OP_PUSHREGS", "mnemonic": "pushregs", "opname": "pushregs", + "widths": "0, 0, 0", + "types": "ev_invalid, ev_invalid, ev_invalid", "format": None, } pop_formats = { @@ -233,6 +293,8 @@ pop_formats = { "mnemonic": "pop", "opname": "pop", "format": "{pop_fmt[mm]}", + "widths": "{ss+1}, 0, 0", + "types": "ev_void, ev_void, ev_invalid", "args": { "op_mode": "ABCD", "pop_fmt": [ @@ -247,23 +309,34 @@ popregs_formats = { "opcode": "OP_POPREGS", "mnemonic": "popregs", "opname": "popregs", + "widths": "0, 0, 0", "format": None, + "types": "ev_invalid, ev_invalid, ev_invalid", } scale_formats = { "opcode": "OP_SCALE_{scale_type[t]}_{ss+1}", "mnemonic": "scale.{scale_type[t]}", "opname": "scale", + "widths": "{ss+1}, 1, {ss+1}", + "types": "{scale_types[t]}, {scale_types[t]}, {scale_types[t]}", "args": { - "scale_type":['F', 'D'], + "scale_type": ['F', 'D'], + "scale_types": float_t, }, } shiftops_formats = { "opcode": "OP_{op_shift[u*2+r].upper()}_{shift_type[u*2+t]}_{ss+1}", "mnemonic": "{op_shift[u*2+r]}.{shift_type[u*2+t]}", "opname": "{op_shift[u*2+r]}", + "widths": "{ss+1}, {ss+1}, {ss+1}", + "types": "{shift_types[t][u]}, {shift_types[t][0]}, {shift_types[t][u]}", "args": { "op_shift": ["shl", "asr", "shl", "shr"], - "shift_type":['I', 'L', 'u', 'U'], + "shift_type": ['I', 'L', 'u', 'U'], + "shift_types": [ + ["ev_integer", "ev_uinteger"], + ["ev_long", "ev_ulong"], + ], }, } state_formats = { @@ -271,9 +344,12 @@ state_formats = { "mnemonic": "state.{state[t]}", "opname": "state", "format": "{state_fmt[t]}", + "widths": "1, 1, 1", + "types": "ev_float, ev_func, {state_types[t]}", "args": { "state": ["ft", "ftt"], "state_fmt": ["%Ga, %Gb", "%Ga, %Gb, %Gc"], + "state_types": ["ev_invalid", "ev_float"], }, } store_formats = { @@ -281,6 +357,8 @@ store_formats = { "mnemonic": "store", "opname": "store", "format": "{store_fmt[mm]}", + "widths": "{ss+1}, 0, {ss+1}", + "types": "ev_void, ev_void, ev_void", "args": { "op_mode": "ABCD", "store_fmt": [ @@ -296,6 +374,8 @@ string_formats = { "mnemonic": "{op_str[o*4+oo]}.s", "opname": "{op_str[o*4+oo]}", "format": "{str_fmt[o*4+oo]}", + "widths": "1, 1, 1", + "types": "{str_types[o*4+oo]}", "args": { "op_str": ["eq", "lt", "gt", "add", "cmp", "ge", "le", "not"], "str_fmt": [ @@ -308,6 +388,16 @@ string_formats = { "%Ga, %Gb, %gc", "%Ga, %gc", ], + "str_types": [ + "ev_string, ev_string, ev_integer", + "ev_string, ev_string, ev_integer", + "ev_string, ev_string, ev_integer", + "ev_string, ev_string, ev_string", + "ev_string, ev_string, ev_integer", + "ev_string, ev_string, ev_integer", + "ev_string, ev_string, ev_integer", + "ev_string, ev_invalid, ev_integer", + ], }, } swizzle_formats = { @@ -315,8 +405,11 @@ swizzle_formats = { "mnemonic": "swizzle.{swiz_type[t]}", "opname": "swizzle", "format": "%Ga %sb %gc", + "widths": "4, 0, 4", + "types": "{swizzle_types[t]}", "args": { - "swiz_type":['F', 'D'], + "swiz_type": ['F', 'D'], + "swizzle_types": float_t, }, } rcall_formats = { @@ -324,6 +417,8 @@ rcall_formats = { "mnemonic": "rcall{nnn+1}", "opname": "rcall{nnn+1}", "format": "{rcall_fmt[nnn]}", + "widths": "0, 0, 0", + "types": "ev_func, ev_void, ev_void", "args": { "rcall_fmt": [ "%Fa (%P0b)", @@ -341,31 +436,51 @@ return_formats = { "opcode": "OP_RETURN_{ss+1}", "mnemonic": "return{ss+1}", "opname": "return{ss+1}", + "widths": "0, 0, 0", "format": "%Ra", + "types": "ev_void, ev_invalid, ev_invalid", } returnv_formats = { "opcode": "OP_RETURN_0", "mnemonic": "return", "opname": "return", + "widths": "0, 0, 0", "format": None, + "types": "ev_invalid, ev_invalid, ev_invalid", } vecops_formats = { "opcode": "OP_{op_vop[ooo].upper()}_{vop_type[t]}", "mnemonic": "{op_vop[ooo]}.{vop_type[t]}", "opname": "{op_vop[ooo]}", + "widths": "{vec_widths[ooo]}", + "types": "{vec_types[t]}, {vec_types[t]}, {vec_types[t]}", "args": { "op_vop": ["cdot", "vdot", "qdot", "cross", "cmul", "qvmul", "vqmul", "qmul"], "vop_type": ['F', 'D'], + "vec_widths": [ + "2, 2, 2", + "3, 3, 3", + "4, 4, 4", + "3, 3, 3", + "2, 2, 2", + "4, 3, 3", + "3, 4, 3", + "4, 4, 4", + ], + "vec_types": float_t, }, } vecops2_formats = { "opcode": "OP_{op_vop[dd].upper()}_{vop_type[t]}", "mnemonic": "{op_vop[dd]}.{vop_type[t]}", "opname": "{op_vop[dd]}", + "widths": "4, 4, 4", + "types": "{vec_types[t]}, {vec_types[t]}, {vec_types[t]}", "args": { "op_vop": [None, "qv4mul", "v4qmul", None], "vop_type": ['F', 'D'], + "vec_types": float_t, }, } with_formats = { @@ -373,6 +488,8 @@ with_formats = { "mnemonic": "with", "opname": "with", "format": "%sa, %sb, $sc", + "widths": "0, 0, 0", + "types": "ev_void, ev_void, ev_void", } group_map = { @@ -475,6 +592,8 @@ def process_opcode(opcode, group): else: fmt = f'"{fmt}"' inst["fmt"] = fmt + inst["wd"] = "{%s}" % eval(f'''f"{gm['widths']}"''', params) + inst["ty"] = "{%s}" % eval(f'''f"{gm['types']}"''', params) lines = bitmap_txt.split('\n') for l in lines: @@ -499,5 +618,7 @@ for i, group in enumerate(opcodes): print(eval('f"[{op}] = {{\\n' '\\t.opname = {on},\\n' '\\t.mnemonic = {mn},\\n' + '\\t.widths = {wd},\\n' + '\\t.types = {ty},\\n' '\\t.fmt = {fmt},\\n' '}},"', group)) From d9d37fda4763219243cbb9af3188fb359c3d1372 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 6 Jan 2022 11:47:05 +0900 Subject: [PATCH 044/360] [gamecode] Implement ruamoko opcode lookup And get the debugger working with the new instruction set. --- libs/gamecode/pr_debug.c | 51 +++++++++++++++++++++++++++------------ libs/gamecode/pr_opcode.c | 7 ++++++ libs/gamecode/test/main.c | 7 +++++- 3 files changed, 49 insertions(+), 16 deletions(-) diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 7e3090a76..98c5d0e59 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -1513,11 +1513,13 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) int addr = s - pr->pr_statements; int dump_code = contents & 2; const char *fmt; - const v6p_opcode_t *op; + const char *mnemonic; dfunction_t *call_func = 0; pr_def_t *parm_def = 0; pr_auxfunction_t *aux_func = 0; pr_debug_data_t data; + etype_t op_type[3]; + int op_width[3]; dstring_clearstr (res->line); @@ -1539,24 +1541,43 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) return; } - op = PR_v6p_Opcode (s->op); - if (!op) { - Sys_Printf ("%sUnknown instruction %d\n", res->line->str, s->op); - return; + if (pr->progs->version < PROG_VERSION) { + const v6p_opcode_t *op = PR_v6p_Opcode (s->op); + if (!op) { + Sys_Printf ("%sUnknown instruction %d\n", res->line->str, s->op); + return; + } + VectorSet (op->type_a, op->type_b, op->type_c, op_type); + VectorSet (1, 1, 1, op_width); + fmt = op->fmt; + mnemonic = op->opname; + } else { + const opcode_t *op = PR_Opcode (s->op); + if (!op) { + Sys_Printf ("%sUnknown instruction %d\n", res->line->str, s->op); + return; + } + VectorCopy (op->widths, op_width); + VectorCopy (op->types, op_type); + fmt = op->fmt; + mnemonic = op->mnemonic; } - if (!(fmt = op->fmt)) + if (!fmt) { fmt = "%Ga, %Gb, %gc"; + } dasprintf (res->line, "%04x ", addr); - if (pr_debug->int_val > 2) - dasprintf (res->line, "%02x %04x(%8s) %04x(%8s) %04x(%8s)\t", + if (pr_debug->int_val > 2) { + dasprintf (res->line, + "%02x %04x(%8s)[%d] %04x(%8s)[%d] %04x(%8s)[%d]\t", s->op, - s->a, pr_type_name[op->type_a], - s->b, pr_type_name[op->type_b], - s->c, pr_type_name[op->type_c]); + s->a, pr_type_name[op_type[0]], op_width[0], + s->b, pr_type_name[op_type[1]], op_width[1], + s->c, pr_type_name[op_type[2]], op_width[2]); + } - dasprintf (res->line, "%s ", op->opname); + dasprintf (res->line, "%s ", mnemonic); while (*fmt) { if (*fmt == '%') { @@ -1582,15 +1603,15 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) switch (opchar) { case 'a': opval = s->a; - optype = res->type_encodings[op->type_a]; + optype = res->type_encodings[op_type[0]]; break; case 'b': opval = s->b; - optype = res->type_encodings[op->type_b]; + optype = res->type_encodings[op_type[1]]; break; case 'c': opval = s->c; - optype = res->type_encodings[op->type_c]; + optype = res->type_encodings[op_type[2]]; break; case 'x': if (mode == 'P') { diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index e2bebf46c..add538502 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -36,3 +36,10 @@ const opcode_t pr_opcodes[512] = { #include "libs/gamecode/pr_opcode.cinc" }; + +const opcode_t * +PR_Opcode (pr_ushort_t opcode) +{ + opcode &= OP_MASK; + return &pr_opcodes[opcode]; +} diff --git a/libs/gamecode/test/main.c b/libs/gamecode/test/main.c index 44e91167e..0579463b2 100644 --- a/libs/gamecode/test/main.c +++ b/libs/gamecode/test/main.c @@ -43,12 +43,15 @@ test_debug_handler (prdebug_t event, void *param, void *data) break; case prd_trace: dstatement_t *st = test_pr.pr_statements + test_pr.pr_xstatement; - if (verbose > 0) { + if (verbose > 1) { printf ("debug: trace %05x %04x %04x %04x %04x%s\n", test_pr.pr_xstatement, st->op, st->a, st->b, st->c, pr->globals.stack ? va (0, " %05x", *pr->globals.stack) : ""); } + if (verbose > 0) { + PR_PrintStatement (&test_pr, st, 0); + } if (pr->globals.stack) { if (*pr->globals.stack & 3) { printf ("stack not aligned: %d\n", *pr->globals.stack); @@ -73,6 +76,8 @@ static void setup_test (test_t *test) { memset (&test_pr, 0, sizeof (test_pr)); + PR_Init (&test_pr); + PR_Debug_Init (&test_pr); test_pr.progs = &test_progs; test_pr.debug_handler = test_debug_handler; test_pr.debug_data = &test_pr; From c0277c0b0350a6b1ea19729f0ff0715570948110 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 6 Jan 2022 11:51:38 +0900 Subject: [PATCH 045/360] [gamecode] Fix incorrect entity load format Had a typo in load and forgot to edit lea, but now they share the formats (like they should have in the first place). --- libs/gamecode/opcodes.py | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index dbb315009..81bbb7e29 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -36,7 +36,13 @@ n 1111 nnnn 0 1011 nnnn """ -branch_fmt=[ +load_fmt = [ + "%Ga.%Gb(%Ea), %gc", + "*%Ga, %gc", + "*(%Ga + %sb), %gc", + "*(%Ga + %Gb), %gc", +] +branch_fmt = [ "branch %sa (%Ob)", "*%Ga", "%Ga[%sb]", @@ -47,6 +53,7 @@ type_tt = ['I', 'F', 'L', 'D'] etype_tt = ["ev_integer", "ev_float", "ev_long", "ev_double"] unsigned_t = ["ev_uinteger", "ev_ulong"] float_t = ["ev_float", "ev_double"] + all_formats = { "opcode": "OP_ALL_{ss+1}", "mnemonic": "all", @@ -198,7 +205,8 @@ lea_e_formats = { "opcode": "OP_LEA_E", "mnemonic": "lea", "opname": "lea", - "format": "%Ga.%Gb(%Ec), %gc", + "format": "{load_fmt[0]}", + "format": "%Ga.%Gb(%Ea), %gc", "types": "ev_entity, ev_field, ev_pointer", "widths": "0, 0, 1", } @@ -211,12 +219,7 @@ load_formats = { "types": "ev_void, ev_void, ev_void", "args": { "op_mode": "EBCD", - "load_fmt": [ - "%Ga.%Gb(%Ex), %gc", - "*%Ga, %gc", - "*(%Ga + %sb), %gc", - "*(%Ga + %Gb), %gc", - ], + "load_fmt": load_fmt, }, } mathops_formats = { From 80c5e2c3f63cd0872c299cb2153e0531898bee3a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 6 Jan 2022 18:06:56 +0900 Subject: [PATCH 046/360] [simd] Remove requirements for AVX2 for vec4d It seems gcc-11 does a pretty good job of emulating the instructions (it no longer requires avx2 for 256-bit wide vectors). --- include/QF/simd/types.h | 2 -- include/QF/simd/vec4d.h | 18 +++++++----------- libs/util/test/test-simd.c | 10 ---------- 3 files changed, 7 insertions(+), 23 deletions(-) diff --git a/include/QF/simd/types.h b/include/QF/simd/types.h index ad8345f44..1f2a511c1 100644 --- a/include/QF/simd/types.h +++ b/include/QF/simd/types.h @@ -43,7 +43,6 @@ typedef double vec3d_t[3]; VEC_TYPE (double, vec2d_t, 2); VEC_TYPE (int64_t, vec2l_t, 2); -#ifdef __AVX2__ /** Four element vector type for horizontal (AOS) vector data. * * This is used for both vectors (3D and 4D) and quaternions. 3D vectors @@ -58,7 +57,6 @@ VEC_TYPE (double, vec4d_t, 4); /** Used mostly for __builtin_shuffle. */ VEC_TYPE (int64_t, vec4l_t, 4); -#endif /** Three element vector type for interfacing with compact data. * diff --git a/include/QF/simd/vec4d.h b/include/QF/simd/vec4d.h index d0e3f19bc..1e1d7bb89 100644 --- a/include/QF/simd/vec4d.h +++ b/include/QF/simd/vec4d.h @@ -28,7 +28,6 @@ #ifndef __QF_simd_vec4d_h #define __QF_simd_vec4d_h -#ifdef __AVX2__ #include #include "QF/simd/types.h" @@ -96,9 +95,9 @@ GNU89INLINE inline vec4d_t qrotd (vec4d_t a, vec4d_t b) __attribute__((const)); GNU89INLINE inline vec4d_t qconjd (vec4d_t q) __attribute__((const)); GNU89INLINE inline vec4d_t loadvec3d (const double v3[]) __attribute__((pure)); GNU89INLINE inline void storevec3d (double v3[3], vec4d_t v4); -GNU89INLINE inline vec4l_t loadvec3l (const long *v3) __attribute__((pure)); -GNU89INLINE inline vec4l_t loadvec3l1 (const long *v3) __attribute__((pure)); -GNU89INLINE inline void storevec3l (long *v3, vec4l_t v4); +GNU89INLINE inline vec4l_t loadvec3l (const int64_t *v3) __attribute__((pure)); +GNU89INLINE inline vec4l_t loadvec3l1 (const int64_t *v3) __attribute__((pure)); +GNU89INLINE inline void storevec3l (int64_t *v3, vec4l_t v4); #ifndef IMPLEMENT_VEC4D_Funcs GNU89INLINE inline @@ -187,8 +186,7 @@ qmuld (vec4d_t a, vec4d_t b) vec4d_t c = crossd (a, b) + a * b[3] + a[3] * b; vec4d_t d = dotd (a, b); // zero out the vector component of dot product so only the scalar remains - d = _mm256_permute2f128_pd (d, d, 0x18); - d = _mm256_permute4x64_pd (d, 0xc0); + d = (vec4d_t) { 0, 0, 0, d[3] }; return c - d; } @@ -302,7 +300,7 @@ GNU89INLINE inline VISIBLE #endif vec4l_t -loadvec3l (const long *v3) +loadvec3l (const int64_t *v3) { vec4l_t v4 = { v3[0], v3[1], v3[2], 0 }; return v4; @@ -314,7 +312,7 @@ GNU89INLINE inline VISIBLE #endif vec4l_t -loadvec3l1 (const long *v3) +loadvec3l1 (const int64_t *v3) { vec4l_t v4 = { v3[0], v3[1], v3[2], 1 }; return v4; @@ -326,13 +324,11 @@ GNU89INLINE inline VISIBLE #endif void -storevec3l (long *v3, vec4l_t v4) +storevec3l (int64_t *v3, vec4l_t v4) { v3[0] = v4[0]; v3[1] = v4[1]; v3[2] = v4[2]; } -#endif - #endif//__QF_simd_vec4d_h diff --git a/libs/util/test/test-simd.c b/libs/util/test/test-simd.c index d1b4bf286..7cba48f3b 100644 --- a/libs/util/test/test-simd.c +++ b/libs/util/test/test-simd.c @@ -48,7 +48,6 @@ #define s05 0.70710678118654757 -#ifdef __AVX2__ typedef struct { int line; vec4d_t (*op) (vec4d_t a, vec4d_t b); @@ -57,7 +56,6 @@ typedef struct { vec4d_t expect; vec4d_t ulp_errors; } vec4d_test_t; -#endif typedef struct { int line; @@ -94,7 +92,6 @@ typedef struct { mat4f_t ulp_errors; } mq4f_test_t; -#ifdef __AVX2__ static vec4d_t tvtruncd (vec4d_t v, vec4d_t ignore) { return vtrunc4d (v); @@ -114,7 +111,6 @@ static vec4d_t tqconjd (vec4d_t v, vec4d_t ignore) { return qconjd (v); } -#endif static vec4f_t tvtruncf (vec4f_t v, vec4f_t ignore) { @@ -158,7 +154,6 @@ static vec4f_t tmagnitude3f (vec4f_t v, vec4f_t ignore) #define T(t...) { __LINE__, t } -#ifdef __AVX2__ static vec4d_test_t vec4d_tests[] = { // 3D dot products T(dotd, right, right, one ), @@ -285,7 +280,6 @@ static vec4d_test_t vec4d_tests[] = { T(tqconjd, one, {}, { -1, -1, -1, 1 } ), }; #define num_vec4d_tests (sizeof (vec4d_tests) / (sizeof (vec4d_tests[0]))) -#endif static vec4f_test_t vec4f_tests[] = { // 3D dot products @@ -487,7 +481,6 @@ static mq4f_test_t mq4f_tests[] = { }; #define num_mq4f_tests (sizeof (mq4f_tests) / (sizeof (mq4f_tests[0]))) -#ifdef __AVX2__ static int run_vec4d_tests (void) { @@ -512,7 +505,6 @@ run_vec4d_tests (void) } return ret; } -#endif static int run_vec4f_tests (void) @@ -684,9 +676,7 @@ int main (void) { int ret = 0; -#ifdef __AVX2__ ret |= run_vec4d_tests (); -#endif ret |= run_vec4f_tests (); ret |= run_mat4f_tests (); ret |= run_mv4f_tests (); From c3317f8e5e8c3db1f1b10fc2c081402bf5e67b1e Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 6 Jan 2022 22:20:16 +0900 Subject: [PATCH 047/360] [gamecode] use INT64_C instead of l-suffix Once again, I had forgotten that long is not always 64-bits. --- libs/gamecode/pr_exec.c | 65 +++++++++++++++++++++-------------------- 1 file changed, 33 insertions(+), 32 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 717364ea3..fc0344578 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -2588,41 +2588,42 @@ pr_swizzle_d (pr_lvec4_t vec, pr_ushort_t swiz) &&swizzle_xwww, &&swizzle_ywww, &&swizzle_zwww, &&swizzle_wwww, }; #undef swizzle +#define L(x) UINT64_C(x) static const pr_lvec4_t neg[16] = { - { 0l, 0l, 0l, 0l }, - { 1l<<63, 0l, 0l, 0l }, - { 0l, 1l<<63, 0l, 0l }, - { 1l<<63, 1l<<63, 0l, 0l }, - { 0l, 0l, 1l<<63, 0l }, - { 1l<<63, 0l, 1l<<63, 0l }, - { 0l, 1l<<63, 1l<<63, 0l }, - { 1l<<63, 1l<<63, 1l<<63, 0l }, - { 0l, 0l, 0l, 1l<<63 }, - { 1l<<63, 0l, 0l, 1l<<63 }, - { 0l, 1l<<63, 0l, 1l<<63 }, - { 1l<<63, 1l<<63, 0l, 1l<<63 }, - { 0l, 0l, 1l<<63, 1l<<63 }, - { 1l<<63, 0l, 1l<<63, 1l<<63 }, - { 0l, 1l<<63, 1l<<63, 1l<<63 }, - { 1l<<63, 1l<<63, 1l<<63, 1l<<63 }, + { INT64_C(0), INT64_C(0), INT64_C(0), INT64_C(0) }, + { INT64_C(1)<<63, INT64_C(0), INT64_C(0), INT64_C(0) }, + { INT64_C(0), INT64_C(1)<<63, INT64_C(0), INT64_C(0) }, + { INT64_C(1)<<63, INT64_C(1)<<63, INT64_C(0), INT64_C(0) }, + { INT64_C(0), INT64_C(0), INT64_C(1)<<63, INT64_C(0) }, + { INT64_C(1)<<63, INT64_C(0), INT64_C(1)<<63, INT64_C(0) }, + { INT64_C(0), INT64_C(1)<<63, INT64_C(1)<<63, INT64_C(0) }, + { INT64_C(1)<<63, INT64_C(1)<<63, INT64_C(1)<<63, INT64_C(0) }, + { INT64_C(0), INT64_C(0), INT64_C(0), INT64_C(1)<<63 }, + { INT64_C(1)<<63, INT64_C(0), INT64_C(0), INT64_C(1)<<63 }, + { INT64_C(0), INT64_C(1)<<63, INT64_C(0), INT64_C(1)<<63 }, + { INT64_C(1)<<63, INT64_C(1)<<63, INT64_C(0), INT64_C(1)<<63 }, + { INT64_C(0), INT64_C(0), INT64_C(1)<<63, INT64_C(1)<<63 }, + { INT64_C(1)<<63, INT64_C(0), INT64_C(1)<<63, INT64_C(1)<<63 }, + { INT64_C(0), INT64_C(1)<<63, INT64_C(1)<<63, INT64_C(1)<<63 }, + { INT64_C(1)<<63, INT64_C(1)<<63, INT64_C(1)<<63, INT64_C(1)<<63 }, }; static const pr_lvec4_t zero[16] = { - { ~0l, ~0l, ~0l, ~0l }, - { 0l, ~0l, ~0l, ~0l }, - { ~0l, 0l, ~0l, ~0l }, - { 0l, 0l, ~0l, ~0l }, - { ~0l, ~0l, 0l, ~0l }, - { 0l, ~0l, 0l, ~0l }, - { ~0l, 0l, 0l, ~0l }, - { 0l, 0l, 0l, ~0l }, - { ~0l, ~0l, ~0l, 0l }, - { 0l, ~0l, ~0l, 0l }, - { ~0l, 0l, ~0l, 0l }, - { 0l, 0l, ~0l, 0l }, - { ~0l, ~0l, 0l, 0l }, - { 0l, ~0l, 0l, 0l }, - { ~0l, 0l, 0l, 0l }, - { 0l, 0l, 0l, 0l }, + { ~INT64_C(0), ~INT64_C(0), ~INT64_C(0), ~INT64_C(0) }, + { INT64_C(0), ~INT64_C(0), ~INT64_C(0), ~INT64_C(0) }, + { ~INT64_C(0), INT64_C(0), ~INT64_C(0), ~INT64_C(0) }, + { INT64_C(0), INT64_C(0), ~INT64_C(0), ~INT64_C(0) }, + { ~INT64_C(0), ~INT64_C(0), INT64_C(0), ~INT64_C(0) }, + { INT64_C(0), ~INT64_C(0), INT64_C(0), ~INT64_C(0) }, + { ~INT64_C(0), INT64_C(0), INT64_C(0), ~INT64_C(0) }, + { INT64_C(0), INT64_C(0), INT64_C(0), ~INT64_C(0) }, + { ~INT64_C(0), ~INT64_C(0), ~INT64_C(0), INT64_C(0) }, + { INT64_C(0), ~INT64_C(0), ~INT64_C(0), INT64_C(0) }, + { ~INT64_C(0), INT64_C(0), ~INT64_C(0), INT64_C(0) }, + { INT64_C(0), INT64_C(0), ~INT64_C(0), INT64_C(0) }, + { ~INT64_C(0), ~INT64_C(0), INT64_C(0), INT64_C(0) }, + { INT64_C(0), ~INT64_C(0), INT64_C(0), INT64_C(0) }, + { ~INT64_C(0), INT64_C(0), INT64_C(0), INT64_C(0) }, + { INT64_C(0), INT64_C(0), INT64_C(0), INT64_C(0) }, }; do_swizzle: From 0d9294d541ac60eadbf38d2a90cb641c346672a6 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 6 Jan 2022 22:21:24 +0900 Subject: [PATCH 048/360] [gamesource] Work around a windows gcc bug The bug (alignment issues with AVX on windows) seems to have in gcc from the 4.x days, and is still present in 11.2: it does not ensure stack parameters that need 32 byte alignment are aligned. Telling gcc to use the sysv abi (safe on a static function) lets gcc do what it does for linux (usually pass the parameters in registers, which it seems to have done). --- libs/gamecode/pr_exec.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index fc0344578..f43011a79 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -2261,6 +2261,11 @@ negate: } static pr_lvec4_t +#ifdef _WIN64 +//force gcc to use registers for the parameters to avoid alignment issues +//on the stack (gcc bug as of 11.2) +__attribute__((sysv_abi)) +#endif pr_swizzle_d (pr_lvec4_t vec, pr_ushort_t swiz) { goto do_swizzle; From 1cb35b1fe399149ba83d38bb0f48e67cf11ad67d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 6 Jan 2022 22:27:09 +0900 Subject: [PATCH 049/360] [gamecode] Fix some more operand formats With and relative branches. --- libs/gamecode/opcodes.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 81bbb7e29..f0f2a1c26 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -43,7 +43,7 @@ load_fmt = [ "*(%Ga + %Gb), %gc", ] branch_fmt = [ - "branch %sa (%Ob)", + "branch %sa (%Oa)", "*%Ga", "%Ga[%sb]", "%Ga[%Gb]", @@ -490,7 +490,7 @@ with_formats = { "opcode": "OP_WITH", "mnemonic": "with", "opname": "with", - "format": "%sa, %sb, $sc", + "format": "%sa, %sb, %sc", "widths": "0, 0, 0", "types": "ev_void, ev_void, ev_void", } From aee31a8be514847166a6a34f0d29237e926a1e6b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 6 Jan 2022 22:27:42 +0900 Subject: [PATCH 050/360] [sys] Use tailless INT64_C macro I guess I missed the non-internal version when searching for it before. --- libs/util/sys.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/util/sys.c b/libs/util/sys.c index 25120aed2..bd985428f 100644 --- a/libs/util/sys.c +++ b/libs/util/sys.c @@ -431,7 +431,7 @@ Sys_LongTime (void) VISIBLE int64_t Sys_TimeBase (void) { - return __INT64_C (4294967296000000); + return INT64_C (4294967296000000); } VISIBLE double From 23613ca985b40701e3378589f6e98fd2849aa627 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 7 Jan 2022 11:46:45 +0900 Subject: [PATCH 051/360] [simd] Get the new functions working on older hardware In some cases, gcc-11 does a good enough job translating normal looking C expressions so use just those, but other times need to dig around for an appropriate intrinsic. Also, now need to disable psapi warnings when compiling for anything less than avx. --- config.d/compiling.m4 | 8 ++++++- include/QF/simd/vec2d.h | 28 +++++++++++++++++++++++- include/QF/simd/vec2f.h | 21 ++++++++++++++++++ include/QF/simd/vec2i.h | 12 +++++++++++ include/QF/simd/vec4d.h | 47 ++++++++++++++++++++++++++++++++++++++++- include/QF/simd/vec4i.h | 22 ++++++++++++------- 6 files changed, 127 insertions(+), 11 deletions(-) diff --git a/config.d/compiling.m4 b/config.d/compiling.m4 index 1cd08dfa4..7fd5bd6c2 100644 --- a/config.d/compiling.m4 +++ b/config.d/compiling.m4 @@ -92,7 +92,6 @@ AC_ARG_ENABLE(simd, case "$enable_simd" in no) - QF_CC_OPTION(-Wno-psabi) simd=no ;; sse|sse2|avx|avx2) @@ -108,6 +107,13 @@ case "$enable_simd" in done ;; esac +case "$simd" in + avx*) + ;; + *) + QF_CC_OPTION(-Wno-psabi) + ;; +esac AC_MSG_CHECKING(for optimization) if test "x$optimize" = xyes -a "x$leave_cflags_alone" != "xyes"; then diff --git a/include/QF/simd/vec2d.h b/include/QF/simd/vec2d.h index 206e7f18b..86be9302b 100644 --- a/include/QF/simd/vec2d.h +++ b/include/QF/simd/vec2d.h @@ -61,7 +61,14 @@ VISIBLE vec2d_t vceil2d (vec2d_t v) { +#ifndef __SSE4_1__ + return (vec2d_t) { + ceil (v[0]), + ceil (v[1]), + }; +#else return _mm_ceil_pd (v); +#endif } #ifndef IMPLEMENT_VEC2D_Funcs @@ -72,7 +79,14 @@ VISIBLE vec2d_t vfloor2d (vec2d_t v) { +#ifndef __SSE4_1__ + return (vec2d_t) { + floor (v[0]), + floor (v[1]), + }; +#else return _mm_floor_pd (v); +#endif } #ifndef IMPLEMENT_VEC2D_Funcs @@ -83,7 +97,14 @@ VISIBLE vec2d_t vtrunc2d (vec2d_t v) { +#ifndef __SSE4_1__ + return (vec2d_t) { + trunc (v[0]), + trunc (v[1]), + }; +#else return _mm_round_pd (v, _MM_FROUND_TRUNC); +#endif } #ifndef IMPLEMENT_VEC2D_Funcs @@ -95,7 +116,8 @@ vec2d_t dot2d (vec2d_t a, vec2d_t b) { vec2d_t c = a * b; - c = _mm_hadd_pd (c, c); + // gcc-11 does a good job with hadd + c = (vec2d_t) { c[0] + c[1], c[0] + c[1] }; return c; } @@ -109,7 +131,11 @@ cmuld (vec2d_t a, vec2d_t b) { vec2d_t c1 = a * b[0]; vec2d_t c2 = a * b[1]; +#ifndef __SSE3__ + return (vec2d_t) { c1[0] - c2[1], c1[1] + c2[0] }; +#else return _mm_addsub_pd (c1, (vec2d_t) { c2[1], c2[0] }); +#endif } #endif//__QF_simd_vec2d_h diff --git a/include/QF/simd/vec2f.h b/include/QF/simd/vec2f.h index b75efcd8e..1459dd37b 100644 --- a/include/QF/simd/vec2f.h +++ b/include/QF/simd/vec2f.h @@ -80,9 +80,16 @@ VISIBLE vec2f_t vceil2f (vec2f_t v) { +#ifndef __SSE4_1__ + return (vec2f_t) { + ceilf (v[0]), + ceilf (v[1]), + }; +#else vec4f_t t = { v[0], v[1], 0, 0 }; t = _mm_ceil_ps (t); return (vec2f_t) { t[0], t[1] }; +#endif } #ifndef IMPLEMENT_VEC2F_Funcs @@ -93,9 +100,16 @@ VISIBLE vec2f_t vfloor2f (vec2f_t v) { +#ifndef __SSE4_1__ + return (vec2f_t) { + floorf (v[0]), + floorf (v[1]), + }; +#else vec4f_t t = { v[0], v[1], 0, 0 }; t = _mm_floor_ps (t); return (vec2f_t) { t[0], t[1] }; +#endif } #ifndef IMPLEMENT_VEC2F_Funcs @@ -106,9 +120,16 @@ VISIBLE vec2f_t vtrunc2f (vec2f_t v) { +#ifndef __SSE4_1__ + return (vec2f_t) { + truncf (v[0]), + truncf (v[1]), + }; +#else vec4f_t t = { v[0], v[1], 0, 0 }; t = _mm_round_ps (t, _MM_FROUND_TRUNC); return (vec2f_t) { t[0], t[1] }; +#endif } #ifndef IMPLEMENT_VEC2F_Funcs diff --git a/include/QF/simd/vec2i.h b/include/QF/simd/vec2i.h index 694d5fa7b..29f2cc57c 100644 --- a/include/QF/simd/vec2i.h +++ b/include/QF/simd/vec2i.h @@ -60,7 +60,11 @@ int any2i (vec2i_t v) { vec2i_t t = _m_pcmpeqd (v, (vec2i_t) {0, 0}); +#ifndef __SSSE3__ + return (t[0] + t[1]) > -2; +#else return _mm_hadd_pi32 (t, t)[0] > -2; +#endif } #ifndef IMPLEMENT_VEC2I_Funcs @@ -72,7 +76,11 @@ int all2i (vec2i_t v) { vec2i_t t = _m_pcmpeqd (v, (vec2i_t) {0, 0}); +#ifndef __SSSE3__ + return (t[0] + t[1]) == 0; +#else return _mm_hadd_pi32 (t, t)[0] == 0; +#endif } #ifndef IMPLEMENT_VEC2I_Funcs @@ -84,7 +92,11 @@ int none2i (vec2i_t v) { vec2i_t t = _m_pcmpeqd (v, (vec2i_t) {0, 0}); +#ifndef __SSSE3__ + return (t[0] + t[1]) == -2; +#else return _mm_hadd_pi32 (t, t)[0] == -2; +#endif } #endif//__QF_simd_vec2i_h diff --git a/include/QF/simd/vec4d.h b/include/QF/simd/vec4d.h index 1e1d7bb89..791c48dde 100644 --- a/include/QF/simd/vec4d.h +++ b/include/QF/simd/vec4d.h @@ -31,6 +31,7 @@ #include #include "QF/simd/types.h" +#include "QF/simd/vec2d.h" GNU89INLINE inline vec4d_t vsqrt4d (vec4d_t v) __attribute__((const)); GNU89INLINE inline vec4d_t vceil4d (vec4d_t v) __attribute__((const)); @@ -107,7 +108,15 @@ VISIBLE vec4d_t vsqrt4d (vec4d_t v) { +#ifndef __AVX__ + vec2d_t xy = { v[0], v[1] }; + vec2d_t zw = { v[2], v[3] }; + xy = vsqrt2d (xy); + zw = vsqrt2d (zw); + return (vec4d_t) { xy[0], xy[1], zw[0], zw[1] }; +#else return _mm256_sqrt_pd (v); +#endif } #ifndef IMPLEMENT_VEC4D_Funcs @@ -118,7 +127,15 @@ VISIBLE vec4d_t vceil4d (vec4d_t v) { +#ifndef __AVX__ + vec2d_t xy = { v[0], v[1] }; + vec2d_t zw = { v[2], v[3] }; + xy = vceil2d (xy); + zw = vceil2d (zw); + return (vec4d_t) { xy[0], xy[1], zw[0], zw[1] }; +#else return _mm256_ceil_pd (v); +#endif } #ifndef IMPLEMENT_VEC4D_Funcs @@ -129,7 +146,15 @@ VISIBLE vec4d_t vfloor4d (vec4d_t v) { +#ifndef __AVX__ + vec2d_t xy = { v[0], v[1] }; + vec2d_t zw = { v[2], v[3] }; + xy = vfloor2d (xy); + zw = vfloor2d (zw); + return (vec4d_t) { xy[0], xy[1], zw[0], zw[1] }; +#else return _mm256_floor_pd (v); +#endif } #ifndef IMPLEMENT_VEC4D_Funcs @@ -140,7 +165,15 @@ VISIBLE vec4d_t vtrunc4d (vec4d_t v) { +#ifndef __AVX__ + vec2d_t xy = { v[0], v[1] }; + vec2d_t zw = { v[2], v[3] }; + xy = vtrunc2d (xy); + zw = vtrunc2d (zw); + return (vec4d_t) { xy[0], xy[1], zw[0], zw[1] }; +#else return _mm256_round_pd (v, _MM_FROUND_TRUNC); +#endif } #ifndef IMPLEMENT_VEC4D_Funcs @@ -167,7 +200,11 @@ vec4d_t dotd (vec4d_t a, vec4d_t b) { vec4d_t c = a * b; +#ifndef __AVX__ + c = (vec4d_t) { c[0] + c[1], c[0] + c[1], c[2] + c[3], c[2] + c[3] }; +#else c = _mm256_hadd_pd (c, c); +#endif static const vec4l_t A = {2, 3, 0, 1}; c += __builtin_shuffle(c, A); return c; @@ -202,8 +239,12 @@ qvmuld (vec4d_t q, vec4d_t v) double s = q[3]; // zero the scalar of the quaternion. Results in an extra operation, but // avoids adding precision issues. +#ifndef __AVX__ + q = (vec4d_t) { q[0], q[1], q[2], 0 }; +#else vec4d_t z = {}; q = _mm256_blend_pd (q, z, 0x08); +#endif vec4d_t c = crossd (q, v); vec4d_t qv = dotd (q, v); // q.w is 0 so v.w is irrelevant vec4d_t qq = dotd (q, q); @@ -224,8 +265,12 @@ vqmuld (vec4d_t v, vec4d_t q) double s = q[3]; // zero the scalar of the quaternion. Results in an extra operation, but // avoids adding precision issues. +#ifndef __AVX__ + q = (vec4d_t) { q[0], q[1], q[2], 0 }; +#else vec4d_t z = {}; q = _mm256_blend_pd (q, z, 0x08); +#endif vec4d_t c = crossd (q, v); vec4d_t qv = dotd (q, v); // q.w is 0 so v.w is irrelevant vec4d_t qq = dotd (q, q); @@ -262,7 +307,7 @@ qconjd (vec4d_t q) { const uint64_t sign = UINT64_C(1) << 63; const vec4l_t neg = { sign, sign, sign, 0 }; - return _mm256_xor_pd (q, (__m256d) neg); + return (vec4d_t) ((vec4l_t) q ^ neg); } #ifndef IMPLEMENT_VEC4D_Funcs diff --git a/include/QF/simd/vec4i.h b/include/QF/simd/vec4i.h index db303e610..d3e4ac5dc 100644 --- a/include/QF/simd/vec4i.h +++ b/include/QF/simd/vec4i.h @@ -62,10 +62,12 @@ VISIBLE int any4i (vec4i_t v) { +#ifndef __SSE4_1__ + vec4i_t t = (v != (vec4i_t) {}); + return (t[0] + t[1] + t[2] + t[3]) != 0; +#else return !__builtin_ia32_ptestz128 ((__v2di)v, (__v2di)v); - /*vec4i_t t = (v != (vec4i_t) {}); - t = __builtin_ia32_phaddd128 (t, t); - return __builtin_ia32_phaddd128 (t, t)[0] != 0;*/ +#endif } #ifndef IMPLEMENT_VEC2I_Funcs @@ -77,9 +79,11 @@ int all4i (vec4i_t v) { vec4i_t t = (v == (vec4i_t) {}); +#ifndef __SSE4_1__ + return (t[0] + t[1] + t[2] + t[3]) == 0; +#else return __builtin_ia32_ptestz128 ((__v2di)t, (__v2di)t); - /*t = __builtin_ia32_phaddd128 (t, t); - return __builtin_ia32_phaddd128 (t, t)[0] == 0;*/ +#endif } #ifndef IMPLEMENT_VEC2I_Funcs @@ -90,10 +94,12 @@ VISIBLE int none4i (vec4i_t v) { +#ifndef __SSE4_1__ + vec4i_t t = (v != (vec4i_t) {}); + return (t[0] + t[1] + t[2] + t[3]) == 0; +#else return __builtin_ia32_ptestz128 ((__v2di)v, (__v2di)v); - /*vec4i_t t = (v != (vec4i_t) {}); - t = __builtin_ia32_phaddd128 (t, t); - return __builtin_ia32_phaddd128 (t, t)[0] == 0;*/ +#endif } #ifndef IMPLEMENT_VEC4F_Funcs From c96cb1f3027a3354f68c25653329a6a5d6c9aa26 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 7 Jan 2022 15:59:06 +0900 Subject: [PATCH 052/360] [qfcc] Fix some stale documentation comments It does little good for documentation to refer to fields that don't exist (because a certain someone forgot to change the docs when changing the field names, I wonder who :P). --- tools/qfcc/include/obj_file.h | 20 +++++++++----------- 1 file changed, 9 insertions(+), 11 deletions(-) diff --git a/tools/qfcc/include/obj_file.h b/tools/qfcc/include/obj_file.h index 630659276..7fdee6030 100644 --- a/tools/qfcc/include/obj_file.h +++ b/tools/qfcc/include/obj_file.h @@ -218,23 +218,21 @@ typedef struct qfo_func_s { referenced relocs unreferenced relocs - For \c ref_op_* relocation types, \c ofs is the code section address of the - statement that needs to be adjusted. + For \c ref_op_* relocation types, \c offset is the code section address + of the statement that needs to be adjusted. - For \c rel_def_* relocation types, - \c ofs refers to the data section address of the word that needs to be - adjusted. + For \c rel_def_* relocation types, \c offset refers to the data section + address of the word that needs to be adjusted. - For \c ref_*_def(_ofs) relocation types, \c def is the index of the + For \c ref_*_def(_ofs) relocation types, \c target is the index of the referenced def. - For \c ref_*_op relocation types, \c def is the address of - the referenced statement. + For \c ref_*_op relocation types, \c target is the address of the + referenced statement. - For \c ref_*_string relocation types, \c def is - always 0. + For \c ref_*_string relocation types, \c target is always 0. - For \c ref_*_field(_ofs) relocation types, \c def is the index of + For \c ref_*_field(_ofs) relocation types, \c target is the index of the referenced field def. */ typedef struct qfo_reloc_s { From fe153b5b22289ddfad811e7771828ba8c04e24c5 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 7 Jan 2022 17:56:05 +0900 Subject: [PATCH 053/360] [qfcc] Add progs version to qfo and check in linker While qfcc dealing sensibly with mixed target VMs in the object files has always been an outstanding issue, with the new instruction set it has become a priority. Most importantly, this should allow QF to continue building while I work on qfcc targeting the new IS. --- tools/qfcc/include/obj_file.h | 5 ++++- tools/qfcc/source/linker.c | 4 ++++ tools/qfcc/source/obj_file.c | 10 ++++++++++ 3 files changed, 18 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/include/obj_file.h b/tools/qfcc/include/obj_file.h index 7fdee6030..f49688f0f 100644 --- a/tools/qfcc/include/obj_file.h +++ b/tools/qfcc/include/obj_file.h @@ -49,7 +49,7 @@ \hideinitializer */ -#define QFO_VERSION 0x00001006 +#define QFO_VERSION 0x00001007 /** Header block of QFO object files. The sections of the object file come immediately after the header, and are always in the order given by @@ -68,6 +68,8 @@ typedef struct qfo_header_s { pr_uint_t num_lines; ///< number of line records pr_uint_t num_loose_relocs; ///< number of loose relocation records ///< (included in num_relocs) + pr_uint_t progs_version; ///< version of compatible VM + pr_uint_t reserved[3]; } qfo_header_t; typedef enum qfos_type_e { @@ -260,6 +262,7 @@ typedef struct qfo_mspace_s { /** In-memory representation of a QFO object file. */ typedef struct qfo_s { + pr_uint_t progs_version; ///< version of compatible VM void *data; ///< data buffer holding qfo file when read qfo_mspace_t *spaces; unsigned num_spaces; diff --git a/tools/qfcc/source/linker.c b/tools/qfcc/source/linker.c index 4b0fb7d74..948ac084f 100644 --- a/tools/qfcc/source/linker.c +++ b/tools/qfcc/source/linker.c @@ -1148,6 +1148,10 @@ linker_add_lib (const char *libname) linker_error ("error opening"); return 1; } + if (qfo->progs_version != options.code.progsversion) { + linker_error ("qfo progs version does not match target"); + return 1; + } for (j = 0; j < qfo->num_defs; j++) { qfo_def_t *def = qfo->defs + j; diff --git a/tools/qfcc/source/obj_file.c b/tools/qfcc/source/obj_file.c index 22403f7ae..2082fe8ca 100644 --- a/tools/qfcc/source/obj_file.c +++ b/tools/qfcc/source/obj_file.c @@ -480,6 +480,7 @@ qfo_write (qfo_t *qfo, const char *filename) header->num_funcs = LittleLong (qfo->num_funcs); header->num_lines = LittleLong (qfo->num_lines); header->num_loose_relocs = LittleLong (qfo->num_loose_relocs); + header->progs_version = LittleLong (options.code.progsversion); spaces = (qfo_space_t *) &header[1]; relocs = (qfo_reloc_t *) &spaces[qfo->num_spaces]; defs = (qfo_def_t *) &relocs[qfo->num_relocs]; @@ -562,6 +563,14 @@ qfo_read (QFile *file) free (data); return 0; } + header->progs_version = LittleLong (header->progs_version); + if (header->progs_version != PROG_ID_VERSION + && header->progs_version != PROG_V6P_VERSION + && header->progs_version != PROG_VERSION) { + fprintf (stderr, "not a compatible qfo file\n"); + free (data); + return 0; + } qfo = calloc (1, sizeof (qfo_t)); qfo->num_spaces = LittleLong (header->num_spaces); @@ -570,6 +579,7 @@ qfo_read (QFile *file) qfo->num_funcs = LittleLong (header->num_funcs); qfo->num_lines = LittleLong (header->num_lines); qfo->num_loose_relocs = LittleLong (header->num_loose_relocs); + qfo->progs_version = header->progs_version; //already swapped spaces = (qfo_space_t *) &header[1]; qfo->data = data; From 2d245b8cdc2790cb0e5b18522bf6a2a3063eabdd Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 7 Jan 2022 18:34:05 +0900 Subject: [PATCH 054/360] [qfcc] Replace [no-]v6only with target= This allows v6, v6p (older QF VM) or ruamoko (new QF VM) to be targeted. Currently defaults to v6p to allow QF to continue building without too much hassle. --- tools/qfcc/doc/man/qfcc.1 | 37 ++++++++++++++++++++++++++----------- tools/qfcc/source/options.c | 24 +++++++++++++++++------- 2 files changed, 43 insertions(+), 18 deletions(-) diff --git a/tools/qfcc/doc/man/qfcc.1 b/tools/qfcc/doc/man/qfcc.1 index 5d49b816a..893070824 100644 --- a/tools/qfcc/doc/man/qfcc.1 +++ b/tools/qfcc/doc/man/qfcc.1 @@ -190,7 +190,7 @@ Look for \*[progs.src] in \fBDIR\fP instead of the current directory. .TP .B \-\-traditional Use traditional QuakeC syntax, semantics and \*(lqbugs\*(rq. -Also implies the \fBv6only\fP, \fBno-short-circuit\fP, +Also implies the \fBtarget=v6\fP, \fBno-short-circuit\fP, \fBconst-initializers\fP and \fBno-local-merging\fP code generation options (see \fBCODE GENERATION OPTIONS\fP). This is the default when using \fBprogs.src\fP mode. @@ -271,8 +271,8 @@ output file is \*(lqprogs.dat\*(rq, the symbol file will be .B fast\-float Use float values directly in \*(lqif\*(rq statements. Defaults to on. -This option is always enabled when using version 6 progs (\fBv6only\fP is in -effect). +This option is always enabled when targeting v6 progs (\fBtarget=v6\fP is +in effect). .TP .B local-merging @@ -289,8 +289,9 @@ Defaults to off for traditional mode, and on for advanced mode. .TP .B promote\-float Promote float when passed to a function that takes a variable number of -arguements. Defaults to enabled for advanced code, is forced off for -traditional or v6only code (mostly because such code does not have doubles). +arguements. Defaults to enabled for advanced code (v6p or ruamoko), is forced +off for traditional or v6 code (mostly because such code does not have +doubles). .TP .B short\-circuit @@ -329,18 +330,32 @@ Create extra symbols for accessing the components of a vector variable or field. For example, \fBvector vel\fP will also create \fBvel_x\fP, \fBvel_y\fP, and \fBvel_z\fP. Defaults to on for traditional code and off for advanced. +.PP +Any of the above can be prefixed with \fBno\-\fP to negate its meaning. .TP -.B v6only -Restrict the compiler to produce only version 6 progs (original -Quake/QuakeWorld) features. +.B target=v6|v6p|ruamoko +Specify the target for which the compiler is to produce code. +.RS +.TP +.B v6 +Standard Quake VM (qcc compatible). This means that the compiled data file should be able to run on older servers, as long as you have not used any QuakeForge-specific built-in functions. Also disables compiler features (such as integers and string manipulation support) that require extensions. -Defaults to on for traditional mode and off for advanced mode. -.PP -Any of the above can be prefixed with \fBno\-\fP to negate its meaning. +.TP +.B v6p +Quakeforge extended v6 instructions. +This is not compatible with older server, nor with most (any?) other Quake +engine. It adds a variety of instructions and types, including integers, +quaternions, pointers, doubles, structs, arrays and Objective-C style classes. +.TP +.B ruamoko +Quakeforge SIMD instructions. This is currently under development +and thus not the default. +.RE +Defaults to v6 for traditional mode and v6p for advanced mode. .SH "WARNING OPTIONS" diff --git a/tools/qfcc/source/options.c b/tools/qfcc/source/options.c index 671d3aa85..2e701c403 100644 --- a/tools/qfcc/source/options.c +++ b/tools/qfcc/source/options.c @@ -207,8 +207,10 @@ code_usage (void) " passing\n" " vectors to functiosn.\n" " [no-]vector-components Create *_[xyz] symbols for vector variables.\n" -" [no-]v6only Restrict output code to version 6 progs\n" -" features.\n" +" target=v6|v6p|ruamoko Generate code for the specified target VM\n" +" v6 Standard Quake VM (qcc compatible)\n" +" v6p *QuakeForge extended v6 instructions\n" +" ruamoko QuakeForge SIMD instructions\n" "\n" "For details, see the qfcc(1) manual page\n" ); @@ -469,6 +471,19 @@ DecodeArgs (int argc, char **argv) while (temp) { qboolean flag = true; + if (!(strncasecmp (temp, "target=", 7))) { + const char *tgt = temp + 7; + if (!strcasecmp (tgt, "v6")) { + options.code.progsversion = PROG_ID_VERSION; + } else if (!strcasecmp (tgt, "v6p")) { + options.code.progsversion = PROG_V6P_VERSION; + } else if (!strcasecmp (tgt, "ruamoko")) { + options.code.progsversion = PROG_VERSION; + } else { + fprintf (stderr, "unknown target: %s\n", tgt); + exit (1); + } + } if (!strncasecmp (temp, "no-", 3)) { flag = false; temp += 3; @@ -501,11 +516,6 @@ DecodeArgs (int argc, char **argv) options.code.vector_calls = flag; } else if (!(strcasecmp (temp, "vector-components"))) { options.code.vector_components = flag; - } else if (!(strcasecmp (temp, "v6only"))) { - if (flag) - options.code.progsversion = PROG_ID_VERSION; - else - options.code.progsversion = PROG_V6P_VERSION; } else if (!(strcasecmp (temp, "const-initializers"))) { options.code.const_initializers = flag; } From d9ccf3a3945788b3b6068c9fe619005fb6bad062 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 7 Jan 2022 18:54:59 +0900 Subject: [PATCH 055/360] [qfcc] Remove a pile of stale externs Those opcode pointers haven't been used for years. --- tools/qfcc/include/opcodes.h | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/tools/qfcc/include/opcodes.h b/tools/qfcc/include/opcodes.h index f6a95f75a..077d26e1e 100644 --- a/tools/qfcc/include/opcodes.h +++ b/tools/qfcc/include/opcodes.h @@ -31,21 +31,6 @@ #ifndef __opcodes_h #define __opcodes_h -extern struct v6p_opcode_s *op_done; -extern struct v6p_opcode_s *op_return; -extern struct v6p_opcode_s *op_return_v; -extern struct v6p_opcode_s *op_if; -extern struct v6p_opcode_s *op_ifnot; -extern struct v6p_opcode_s *op_ifbe; -extern struct v6p_opcode_s *op_ifb; -extern struct v6p_opcode_s *op_ifae; -extern struct v6p_opcode_s *op_ifa; -extern struct v6p_opcode_s *op_state; -extern struct v6p_opcode_s *op_state_f; -extern struct v6p_opcode_s *op_goto; -extern struct v6p_opcode_s *op_jump; -extern struct v6p_opcode_s *op_jumpb; - struct operand_s; extern struct v6p_opcode_s *opcode_map; From 7e303a11519edfff074f1e08476494ee386b9c49 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 7 Jan 2022 19:05:26 +0900 Subject: [PATCH 056/360] [qfcc] Hide details about instruction type At this stage, I doubt emit.c will need to know the details of the target (v6, v6p, ruamoko) since the instruction formats are identical, just different meanings for the opcode itself. --- tools/qfcc/include/opcodes.h | 13 +++++++------ tools/qfcc/source/emit.c | 8 ++++---- tools/qfcc/source/opcodes.c | 20 +++++++++++++------- 3 files changed, 24 insertions(+), 17 deletions(-) diff --git a/tools/qfcc/include/opcodes.h b/tools/qfcc/include/opcodes.h index 077d26e1e..d8aa393ea 100644 --- a/tools/qfcc/include/opcodes.h +++ b/tools/qfcc/include/opcodes.h @@ -31,13 +31,14 @@ #ifndef __opcodes_h #define __opcodes_h +#include "QF/pr_comp.h" + +typedef struct instruction_s instruction_t; + struct operand_s; - -extern struct v6p_opcode_s *opcode_map; - -struct v6p_opcode_s *opcode_find (const char *name, struct operand_s *op_a, - struct operand_s *op_b, - struct operand_s *op_c); +pr_ushort_t opcode_get (instruction_t *inst); +instruction_t *opcode_find (const char *name, struct operand_s *op_a, + struct operand_s *op_b, struct operand_s *op_c); void opcode_init (void); #endif//__opcodes_h diff --git a/tools/qfcc/source/emit.c b/tools/qfcc/source/emit.c index 48e89b422..10c7054f9 100644 --- a/tools/qfcc/source/emit.c +++ b/tools/qfcc/source/emit.c @@ -185,7 +185,7 @@ emit_statement (statement_t *statement) { const char *opcode = statement->opcode; def_t *def_a, *def_b, *def_c; - v6p_opcode_t *op; + instruction_t *inst; dstatement_t *s; def_a = get_operand_def (statement->expr, statement->opa); @@ -194,9 +194,9 @@ emit_statement (statement_t *statement) use_tempop (statement->opb, statement->expr); def_c = get_operand_def (statement->expr, statement->opc); use_tempop (statement->opc, statement->expr); - op = opcode_find (opcode, statement->opa, statement->opb, statement->opc); + inst = opcode_find (opcode, statement->opa, statement->opb, statement->opc); - if (!op) { + if (!inst) { print_expr (statement->expr); print_statement (statement); internal_error (statement->expr, "ice ice baby"); @@ -213,7 +213,7 @@ emit_statement (statement_t *statement) } } s = codespace_newstatement (pr.code); - s->op = op - opcode_map; + s->op = opcode_get (inst); s->a = def_a ? def_a->offset : 0; s->b = def_b ? def_b->offset : 0; s->c = def_c ? def_c->offset : 0; diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index 8ad5358d9..7060aa35d 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -47,9 +47,9 @@ #include "tools/qfcc/include/statements.h" #include "tools/qfcc/include/type.h" -hashtab_t *opcode_type_table; -hashtab_t *opcode_void_table; -v6p_opcode_t *opcode_map; +static hashtab_t *opcode_type_table; +static hashtab_t *opcode_void_table; +static v6p_opcode_t *opcode_map; #define ROTL(x,n) ((((unsigned)(x))<<(n))|((unsigned)(x))>>(32-n)) @@ -92,7 +92,13 @@ check_operand_type (etype_t ot1, etype_t ot2) return 0; } -v6p_opcode_t * +pr_ushort_t +opcode_get (instruction_t *op) +{ + return (v6p_opcode_t *) op - opcode_map; +} + +instruction_t * opcode_find (const char *name, operand_t *op_a, operand_t *op_b, operand_t *op_c) { @@ -108,10 +114,10 @@ opcode_find (const char *name, operand_t *op_a, operand_t *op_b, search_op.type_c = op_c ? low_level_type (op_c->type) : ev_invalid; op = Hash_FindElement (opcode_type_table, &search_op); if (op) - return op; + return (instruction_t *) op; op_list = Hash_FindList (opcode_void_table, name); if (!op_list) - return op; + return (instruction_t *) op; for (i = 0; !op && op_list[i]; i++) { sop = op_list[i]; if (check_operand_type (sop->type_a, search_op.type_a) @@ -120,7 +126,7 @@ opcode_find (const char *name, operand_t *op_a, operand_t *op_b, op = sop; } free (op_list); - return op; + return (instruction_t *) op; } void From 14d95f81d1ce4170caffca44af8bd01032228953 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 7 Jan 2022 19:25:34 +0900 Subject: [PATCH 057/360] [gamecode] Remove PR_Opcode_Init It was idempotent, then it became impotent. Now it's just not needed. --- include/QF/pr_comp.h | 2 -- libs/gamecode/pr_load.c | 1 - libs/gamecode/pr_v6p_opcode.c | 5 ----- ruamoko/qwaq/builtins/main.c | 4 ---- tools/qfcc/source/opcodes.c | 1 - 5 files changed, 13 deletions(-) diff --git a/include/QF/pr_comp.h b/include/QF/pr_comp.h index 26f0f07e3..9e819ad38 100644 --- a/include/QF/pr_comp.h +++ b/include/QF/pr_comp.h @@ -632,8 +632,6 @@ typedef struct opcode_s { extern const opcode_t pr_opcodes[512]; const opcode_t *PR_Opcode (pr_ushort_t opcode) __attribute__((const)); -void PR_Opcode_Init (void); // idempotent - typedef struct dstatement_s { pr_opcode_e op:16; // will be pr_opcode_v6p_e for older progs pr_ushort_t a,b,c; diff --git a/libs/gamecode/pr_load.c b/libs/gamecode/pr_load.c index 95626fc22..9770bc786 100644 --- a/libs/gamecode/pr_load.c +++ b/libs/gamecode/pr_load.c @@ -479,7 +479,6 @@ PR_Init_Cvars (void) VISIBLE void PR_Init (progs_t *pr) { - PR_Opcode_Init (); // idempotent PR_Resources_Init (pr); PR_Strings_Init (pr); PR_Debug_Init (pr); diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index a4ed63d44..012f23e4a 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -1520,11 +1520,6 @@ PR_v6p_Opcode (pr_ushort_t opcode) return &pr_v6p_opcodes[opcode]; } -VISIBLE void -PR_Opcode_Init (void) -{ -} - static inline void check_branch (progs_t *pr, dstatement_t *st, const v6p_opcode_t *op, short offset) { diff --git a/ruamoko/qwaq/builtins/main.c b/ruamoko/qwaq/builtins/main.c index 3b79f6e5d..f8d4c3a62 100644 --- a/ruamoko/qwaq/builtins/main.c +++ b/ruamoko/qwaq/builtins/main.c @@ -142,10 +142,6 @@ init_qf (void) Cvar_Get ("pr_debug", "2", 0, 0, 0); Cvar_Get ("pr_boundscheck", "0", 0, 0, 0); - - // Normally, this is done by PR_Init, but PR_Init is not called in the main - // thread. However, PR_Opcode_Init() is idempotent. - PR_Opcode_Init (); } static void diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index 7060aa35d..09ec39909 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -139,7 +139,6 @@ opcode_init (void) Hash_FlushTable (opcode_void_table); Hash_FlushTable (opcode_type_table); } else { - PR_Opcode_Init (); opcode_type_table = Hash_NewTable (1021, 0, 0, 0, 0); Hash_SetHashCompare (opcode_type_table, get_hash, compare); opcode_void_table = Hash_NewTable (1021, get_key, 0, 0, 0); From 479d82f38013c283d3a1a8362b4ae32ad8cc73e2 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 7 Jan 2022 19:56:15 +0900 Subject: [PATCH 058/360] [qfcc] Create separate instruction init and lookup v6 vs v6p are more or less as before, with ruamoko added in. qfcc will now try (and fail, due to the opcode table opnames being wrong) to create ruamoko progs when given the ruamoko target option. --- tools/qfcc/source/opcodes.c | 170 ++++++++++++++++++++++++++++++------ 1 file changed, 142 insertions(+), 28 deletions(-) diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index 09ec39909..ee9722a2a 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -47,14 +47,17 @@ #include "tools/qfcc/include/statements.h" #include "tools/qfcc/include/type.h" -static hashtab_t *opcode_type_table; -static hashtab_t *opcode_void_table; -static v6p_opcode_t *opcode_map; +static hashtab_t *v6p_opcode_type_table; +static hashtab_t *v6p_opcode_void_table; +static v6p_opcode_t *v6p_opcode_map; + +static hashtab_t *rua_opcode_type_table; +static hashtab_t *rua_opcode_void_table; #define ROTL(x,n) ((((unsigned)(x))<<(n))|((unsigned)(x))>>(32-n)) static uintptr_t -get_hash (const void *_op, void *_tab) +v6p_get_hash (const void *_op, void *_tab) { v6p_opcode_t *op = (v6p_opcode_t *) _op; uintptr_t hash; @@ -65,7 +68,7 @@ get_hash (const void *_op, void *_tab) } static int -compare (const void *_opa, const void *_opb, void *unused) +v6p_compare (const void *_opa, const void *_opb, void *unused) { v6p_opcode_t *opa = (v6p_opcode_t *) _opa; v6p_opcode_t *opb = (v6p_opcode_t *) _opb; @@ -78,11 +81,41 @@ compare (const void *_opa, const void *_opb, void *unused) } static const char * -get_key (const void *op, void *unused) +v6p_get_key (const void *op, void *unused) { return ((v6p_opcode_t *) op)->name; } +static uintptr_t +rua_get_hash (const void *_op, void *_tab) +{ + opcode_t *op = (opcode_t *) _op; + uintptr_t hash; + + hash = ROTL (~op->types[0], 8) + ROTL (~op->types[1], 16) + + ROTL (~op->types[2], 24); + return hash + Hash_String (op->opname); +} + +static int +rua_compare (const void *_opa, const void *_opb, void *unused) +{ + opcode_t *opa = (opcode_t *) _opa; + opcode_t *opb = (opcode_t *) _opb; + int cmp; + + cmp = (opa->types[0] == opb->types[0]) + && (opa->types[1] == opb->types[1]) + && (opa->types[2] == opb->types[2]); + return cmp && !strcmp (opa->opname, opb->opname); +} + +static const char * +rua_get_key (const void *op, void *unused) +{ + return ((opcode_t *) op)->opname; +} + static int check_operand_type (etype_t ot1, etype_t ot2) { @@ -95,12 +128,16 @@ check_operand_type (etype_t ot1, etype_t ot2) pr_ushort_t opcode_get (instruction_t *op) { - return (v6p_opcode_t *) op - opcode_map; + if (options.code.progsversion < PROG_VERSION) { + return (v6p_opcode_t *) op - v6p_opcode_map; + } else { + return (opcode_t *) op - pr_opcodes; + } } -instruction_t * -opcode_find (const char *name, operand_t *op_a, operand_t *op_b, - operand_t *op_c) +static v6p_opcode_t * +v6p_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, + operand_t *op_c) { v6p_opcode_t search_op = {}; v6p_opcode_t *op; @@ -112,12 +149,12 @@ opcode_find (const char *name, operand_t *op_a, operand_t *op_b, search_op.type_a = op_a ? low_level_type (op_a->type) : ev_invalid; search_op.type_b = op_b ? low_level_type (op_b->type) : ev_invalid; search_op.type_c = op_c ? low_level_type (op_c->type) : ev_invalid; - op = Hash_FindElement (opcode_type_table, &search_op); + op = Hash_FindElement (v6p_opcode_type_table, &search_op); if (op) - return (instruction_t *) op; - op_list = Hash_FindList (opcode_void_table, name); + return op; + op_list = Hash_FindList (v6p_opcode_void_table, name); if (!op_list) - return (instruction_t *) op; + return op; for (i = 0; !op && op_list[i]; i++) { sop = op_list[i]; if (check_operand_type (sop->type_a, search_op.type_a) @@ -126,36 +163,78 @@ opcode_find (const char *name, operand_t *op_a, operand_t *op_b, op = sop; } free (op_list); - return (instruction_t *) op; + return op; } -void -opcode_init (void) +static opcode_t * +rua_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, + operand_t *op_c) +{ + opcode_t search_op = {}; + opcode_t *op; + opcode_t *sop; + void **op_list; + int i; + + search_op.opname = name; + search_op.types[0] = op_a ? low_level_type (op_a->type) : ev_invalid; + search_op.types[1] = op_b ? low_level_type (op_b->type) : ev_invalid; + search_op.types[2] = op_c ? low_level_type (op_c->type) : ev_invalid; + op = Hash_FindElement (rua_opcode_type_table, &search_op); + if (op) + return op; + op_list = Hash_FindList (rua_opcode_void_table, name); + if (!op_list) + return op; + for (i = 0; !op && op_list[i]; i++) { + sop = op_list[i]; + if (check_operand_type (sop->types[0], search_op.types[0]) + && check_operand_type (sop->types[1], search_op.types[1]) + && check_operand_type (sop->types[2], search_op.types[2])) + op = sop; + } + free (op_list); + return op; +} + +instruction_t * +opcode_find (const char *name, operand_t *op_a, operand_t *op_b, + operand_t *op_c) +{ + if (options.code.progsversion < PROG_VERSION) { + return (instruction_t *) v6p_opcode_find (name, op_a, op_b, op_c); + } else { + return (instruction_t *) rua_opcode_find (name, op_a, op_b, op_c); + } +} + +static void +v6p_opcode_init (void) { const v6p_opcode_t *op; v6p_opcode_t *mop; - if (opcode_type_table) { - Hash_FlushTable (opcode_void_table); - Hash_FlushTable (opcode_type_table); + if (v6p_opcode_type_table) { + Hash_FlushTable (v6p_opcode_void_table); + Hash_FlushTable (v6p_opcode_type_table); } else { - opcode_type_table = Hash_NewTable (1021, 0, 0, 0, 0); - Hash_SetHashCompare (opcode_type_table, get_hash, compare); - opcode_void_table = Hash_NewTable (1021, get_key, 0, 0, 0); + v6p_opcode_type_table = Hash_NewTable (1021, 0, 0, 0, 0); + Hash_SetHashCompare (v6p_opcode_type_table, v6p_get_hash, v6p_compare); + v6p_opcode_void_table = Hash_NewTable (1021, v6p_get_key, 0, 0, 0); } int num_opcodes = 0; for (op = pr_v6p_opcodes; op->name; op++) { num_opcodes++; } - if (!opcode_map) { - opcode_map = calloc (num_opcodes, sizeof (v6p_opcode_t)); + if (!v6p_opcode_map) { + v6p_opcode_map = calloc (num_opcodes, sizeof (v6p_opcode_t)); } for (int i = 0; i < num_opcodes; i++) { op = pr_v6p_opcodes + i; if (op->min_version > options.code.progsversion) continue; - mop = opcode_map + i; + mop = v6p_opcode_map + i; *mop = *op; if (options.code.progsversion == PROG_ID_VERSION) { // v6 progs have no concept of integer, but the QF engine @@ -169,9 +248,44 @@ opcode_init (void) if (mop->type_c == ev_integer) mop->type_c = ev_float; } - Hash_AddElement (opcode_type_table, mop); + Hash_AddElement (v6p_opcode_type_table, mop); if (mop->type_a == ev_void || mop->type_b == ev_void || mop->type_c == ev_void) - Hash_Add (opcode_void_table, mop); + Hash_Add (v6p_opcode_void_table, mop); + } +} + +static void +rua_opcode_init (void) +{ + if (rua_opcode_type_table) { + return; + } + + rua_opcode_type_table = Hash_NewTable (1021, 0, 0, 0, 0); + Hash_SetHashCompare (rua_opcode_type_table, rua_get_hash, rua_compare); + rua_opcode_void_table = Hash_NewTable (1021, rua_get_key, 0, 0, 0); + + int num_opcodes = sizeof (pr_opcodes) / sizeof (pr_opcodes[0]); + for (int i = 0; i < num_opcodes; i++) { + const opcode_t *op = pr_opcodes + i; + if (!op->opname) { + continue; + } + Hash_AddElement (rua_opcode_type_table, (opcode_t *) op); + if (op->types[0] == ev_void || op->types[1] == ev_void + || op->types[2] == ev_void) { + Hash_Add (rua_opcode_void_table, (opcode_t *) op); + } + } +} + +void +opcode_init (void) +{ + if (options.code.progsversion < PROG_VERSION) { + v6p_opcode_init (); + } else { + rua_opcode_init (); } } From 8559a4fe2dc896c411401d669792c8f4408ffffb Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 7 Jan 2022 21:48:02 +0900 Subject: [PATCH 059/360] whitespace --- libs/gamecode/opcodes.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index f0f2a1c26..4c0ea838b 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -78,7 +78,7 @@ bitops_formats = { "widths": "{ss+1}, {ss+1}, {ss+1}", "types": "ev_integer, ev_integer, ev_integer", "args": { - "op_bit":["bitand", "bitor", "bitxor", "bitnot"], + "op_bit": ["bitand", "bitor", "bitxor", "bitnot"], "bit_fmt": [ "%Ga, %Gb, %gc", "%Ga, %Gb, %gc", @@ -95,7 +95,7 @@ boolops_formats = { "widths": "{ss+1}, {ss+1}, {ss+1}", "types": "ev_integer, ev_integer, ev_integer", "args": { - "op_bool":["and", "or", "xor", "not"], + "op_bool": ["and", "or", "xor", "not"], "bool_fmt": [ "%Ga, %Gb, %gc", "%Ga, %Gb, %gc", @@ -151,8 +151,8 @@ compare_formats = { "types": "{cmp_types[tt]}, {cmp_types[tt]}, ev_integer", "args": { "op_cmp": compare_ccc, - "cmp_type":type_tt, - "cmp_types":etype_tt, + "cmp_type": type_tt, + "cmp_types": etype_tt, }, } compare2_formats = { @@ -163,8 +163,8 @@ compare2_formats = { "types": "{cmp_types[t]}, {cmp_types[t]}, ev_integer", "args": { "op_cmp": compare_ccc, - "cmp_type":['u', 'U'], - "cmp_types":unsigned_t, + "cmp_type": ['u', 'U'], + "cmp_types": unsigned_t, }, } convert_formats = { @@ -230,7 +230,7 @@ mathops_formats = { "types": "{math_types[tt]}, {math_types[tt]}, {math_types[tt]}", "args": { "op_math": ["mul", "div", "rem", "mod", "add", "sub", None, None], - "math_type":type_tt, + "math_type": type_tt, "math_types": etype_tt, }, } From e186d5064d946c1f90793784d283c8d83f5b54fd Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 7 Jan 2022 21:48:19 +0900 Subject: [PATCH 060/360] [gamecode] Correct return's opname Not meant to have the size in it. --- libs/gamecode/opcodes.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 4c0ea838b..b38763156 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -438,7 +438,7 @@ rcall_formats = { return_formats = { "opcode": "OP_RETURN_{ss+1}", "mnemonic": "return{ss+1}", - "opname": "return{ss+1}", + "opname": "return", "widths": "0, 0, 0", "format": "%Ra", "types": "ev_void, ev_invalid, ev_invalid", From f5be54b6d24ddcc288e2f7b0406f871b172a62e4 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 7 Jan 2022 23:12:20 +0900 Subject: [PATCH 061/360] [qfcc] Sanitize expr type enum Got tired of dealing with out of date string tables. --- tools/qfcc/include/expr.h | 22 ++----------- tools/qfcc/include/expr_names.h | 58 +++++++++++++++++++++++++++++++++ tools/qfcc/source/dot_expr.c | 20 +++--------- 3 files changed, 65 insertions(+), 35 deletions(-) create mode 100644 tools/qfcc/include/expr_names.h diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 5d05f2a40..c9d325e43 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -40,28 +40,12 @@ /** Type of the exression node in an expression tree. */ +#define EX_EXPR(expr) ex_##expr, typedef enum { - ex_error, ///< error expression. used to signal an error - ex_state, ///< state expression (::ex_state_t) - ex_bool, ///< short circuit boolean logic expression (::ex_bool_t) - ex_label, ///< goto/branch label (::ex_label_t) - ex_labelref, ///< label reference (::ex_labelref_t) - ex_block, ///< statement block expression (::ex_block_t) - ex_expr, ///< binary expression (::ex_expr_t) - ex_uexpr, ///< unary expression (::ex_expr_t) - ex_def, ///< non-temporary variable (::def_t) - ex_symbol, ///< non-temporary variable (::symbol_t) - ex_temp, ///< temporary variable (::ex_temp_t) - ex_vector, ///< "vector" expression (::ex_vector_t) - ex_selector, ///< selector expression (::ex_selector_t) - - ex_nil, ///< umm, nil, null. nuff said (0 of any type) - ex_value, ///< constant value (::ex_value_t) - ex_compound, ///< compound initializer - ex_memset, ///< memset needs three params... - +#include "tools/qfcc/include/expr_names.h" ex_count, ///< number of valid expression types } expr_type; +#undef EX_EXPR /** Binary and unary expressions. diff --git a/tools/qfcc/include/expr_names.h b/tools/qfcc/include/expr_names.h new file mode 100644 index 000000000..d29345833 --- /dev/null +++ b/tools/qfcc/include/expr_names.h @@ -0,0 +1,58 @@ +/* + expr.h + + expression construction and manipulations + + Copyright (C) 2022 Bill Currie + + Author: Bill Currie + Date: 2022/01/7 + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + +*/ + +/** \defgroup qfcc_expr Expressions + \ingroup qfcc +*/ +///@{ + +#ifndef EX_EXPR +#define EX_EXPR(expr) +#endif + +EX_EXPR(error) ///< error expression. used to signal an error +EX_EXPR(state) ///< state expression (::ex_state_t) +EX_EXPR(bool) ///< short circuit boolean logic expression (::ex_bool_t) +EX_EXPR(label) ///< goto/branch label (::ex_label_t) +EX_EXPR(labelref) ///< label reference (::ex_labelref_t) +EX_EXPR(block) ///< statement block expression (::ex_block_t) +EX_EXPR(expr) ///< binary expression (::ex_expr_t) +EX_EXPR(uexpr) ///< unary expression (::ex_expr_t) +EX_EXPR(def) ///< non-temporary variable (::def_t) +EX_EXPR(symbol) ///< non-temporary variable (::symbol_t) +EX_EXPR(temp) ///< temporary variable (::ex_temp_t) +EX_EXPR(vector) ///< "vector" expression (::ex_vector_t) +EX_EXPR(selector) ///< selector expression (::ex_selector_t) +EX_EXPR(nil) ///< umm, nil, null. nuff said (0 of any type) +EX_EXPR(value) ///< constant value (::ex_value_t) +EX_EXPR(compound) ///< compound initializer +EX_EXPR(memset) ///< memset needs three params... + +///@} diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index edd1739a9..724213bc1 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -55,25 +55,13 @@ #include "tools/qfcc/source/qc-parse.h" +#define EX_EXPR(expr) #expr, const char *expr_names[] = { - "error", - "state", - "bool", - "label", - "labelref", - "block", - "expr", - "uexpr", - "def", - "symbol", - "temp", - "vector", - "nil", - "value", - "compound", - "memset", +#include "tools/qfcc/include/expr_names.h" + 0 }; +#undef EX_EXPR const char * get_op_string (int op) From ed6b84fbde9d91b47b74d9e2853a7457a933c88c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 8 Jan 2022 03:07:17 +0900 Subject: [PATCH 062/360] [gamecode] Add missed long and ulong info Both pr_type_size and pr_type_name. I want to macroize the enum, but need to sort out the clutter of headers first, just need to decide on naming. This at least sorts out the missed values for now. --- libs/gamecode/pr_v6p_opcode.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index 012f23e4a..421159648 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -57,6 +57,8 @@ VISIBLE const pr_ushort_t pr_type_size[ev_type_count] = { 1, // ev_uinteger 0, // ev_short value in opcode 2, // ev_double + 2, // ev_long + 2, // ev_ulong 0, // ev_invalid not a valid/simple type }; @@ -74,6 +76,8 @@ VISIBLE const char * const pr_type_name[ev_type_count] = { "uinteger", "short", "double", + "long", + "ulong", "invalid", }; From 420d55406f166046e4dd3c2c7daee7d5dfb2b60b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 8 Jan 2022 03:09:15 +0900 Subject: [PATCH 063/360] [qfcc] Add a rule to build the qfcc tests This makes it easier to build and run (by hand) the tests when things aren't working. --- tools/qfcc/test/Makemodule.am | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tools/qfcc/test/Makemodule.am b/tools/qfcc/test/Makemodule.am index d5929e0a6..5d58abb99 100644 --- a/tools/qfcc/test/Makemodule.am +++ b/tools/qfcc/test/Makemodule.am @@ -99,6 +99,8 @@ check_PROGRAMS += \ $(test_progs_dat) \ $(test_bins) +qfcc-tests: tools/qfcc/test/test-harness $(test_progs_dat) $(test_bins) + tools_qfcc_test_test_defspace_SOURCES= tools/qfcc/test/test-defspace.c $(test_defspace_src) tools_qfcc_test_test_defspace_LDADD= $(QFCC_LIBS) tools_qfcc_test_test_defspace_DEPENDENCIES= $(QFCC_DEPS) From 23c9a317f82c4b5fd509d8f34c97190add22f39a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 8 Jan 2022 12:06:52 +0900 Subject: [PATCH 064/360] [qfcc] Give alias expressions their own type While this was a pain to get working, that pain only went to prove the value of using proper "types" (even if only an enum) for different expression types: just finding all the places to edit was a chore, and easy to make mistakes (forgetting bits here and there). Strangely enough, this exposed a pile of *type* aliasing bugs (next commit). --- tools/qfcc/include/expr.h | 7 +++ tools/qfcc/include/expr_names.h | 1 + tools/qfcc/source/constfold.c | 4 +- tools/qfcc/source/def.c | 9 ++- tools/qfcc/source/dot_expr.c | 45 ++++++++------ tools/qfcc/source/expr.c | 103 +++++++++++++++++++++----------- tools/qfcc/source/expr_assign.c | 8 +-- tools/qfcc/source/expr_binary.c | 7 +-- tools/qfcc/source/statements.c | 15 ++--- 9 files changed, 118 insertions(+), 81 deletions(-) diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index c9d325e43..817c82e7b 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -207,6 +207,12 @@ typedef struct ex_value_s { } v; } ex_value_t; +typedef struct { + struct type_s *type; ///< type to view the expression + struct expr_s *expr; ///< the expression to alias + struct expr_s *offset; ///< offset for alias +} ex_alias_t; + #define POINTER_VAL(p) (((p).def ? (p).def->offset : 0) + (p).val) typedef struct expr_s { @@ -233,6 +239,7 @@ typedef struct expr_s { ex_value_t *value; ///< constant value element_chain_t compound; ///< compound initializer ex_memset_t memset; ///< memset expr params + ex_alias_t alias; ///< alias expr params struct type_s *nil; ///< type for nil if known } e; } expr_t; diff --git a/tools/qfcc/include/expr_names.h b/tools/qfcc/include/expr_names.h index d29345833..a37355bcc 100644 --- a/tools/qfcc/include/expr_names.h +++ b/tools/qfcc/include/expr_names.h @@ -54,5 +54,6 @@ EX_EXPR(nil) ///< umm, nil, null. nuff said (0 of any type) EX_EXPR(value) ///< constant value (::ex_value_t) EX_EXPR(compound) ///< compound initializer EX_EXPR(memset) ///< memset needs three params... +EX_EXPR(alias) ///< view expression as different type (::ex_alias_t) ///@} diff --git a/tools/qfcc/source/constfold.c b/tools/qfcc/source/constfold.c index 2459b392f..497f51642 100644 --- a/tools/qfcc/source/constfold.c +++ b/tools/qfcc/source/constfold.c @@ -1718,7 +1718,7 @@ fold_constants (expr_t *e) return e; } op = e->e.expr.op; - if (op == 'A' || op == 'g' || op == 'r') + if (op == 'g' || op == 'r') return e; t1 = extract_type (e1); if (t1 >= ev_type_count || !do_unary_op[t1]) { @@ -1734,7 +1734,7 @@ fold_constants (expr_t *e) } op = e->e.expr.op; - if (op == 'A' || op == 'i' || op == 'n' || op == 'c' || op == 's') { + if (op == 'i' || op == 'n' || op == 'c' || op == 's') { return e; } diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c index 216497a73..94cc49ce1 100644 --- a/tools/qfcc/source/def.c +++ b/tools/qfcc/source/def.c @@ -608,12 +608,11 @@ initialize_def (symbol_t *sym, expr_t *init, defspace_t *space, error (init, "non-constant initializier"); return; } - while ((init->type == ex_uexpr || init->type == ex_expr) - && init->e.expr.op == 'A') { - if (init->type == ex_expr) { - offset += expr_integer (init->e.expr.e2); + while (init->type == ex_alias) { + if (init->e.alias.offset) { + offset += expr_integer (init->e.alias.offset); } - init = init->e.expr.e1; + init = init->e.alias.expr; } if (init->type != ex_value) { //FIXME enum etc internal_error (0, "initializier not a value"); diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index 724213bc1..feaf3defd 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -100,7 +100,6 @@ get_op_string (int op) case 'r': return ""; case 's': return ""; case 'c': return ""; - case 'A': return ""; case 'C': return ""; case 'M': return ""; case 'm': return ""; @@ -314,36 +313,43 @@ print_subexpr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"r\"];\n", indent, "", e, e->e.expr.e2); } - if (e->e.expr.op == 'A') { - dstring_t *typestr = dstring_newstr(); - print_type_str (typestr, e->e.expr.type); - dasprintf (dstr, "%*se_%p [label=\"%s (%s)\\n%d\"];\n", indent, "", e, - get_op_string (e->e.expr.op), typestr->str, e->line); - dstring_delete (typestr); - } else { - dasprintf (dstr, "%*se_%p [label=\"%s\\n%d\"];\n", indent, "", e, - get_op_string (e->e.expr.op), e->line); + dasprintf (dstr, "%*se_%p [label=\"%s\\n%d\"];\n", indent, "", e, + get_op_string (e->e.expr.op), e->line); +} + +static void +print_alias (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) +{ + int indent = level * 2 + 2; + + _print_expr (dstr, e->e.alias.expr, level, id, next); + dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"a\"];\n", indent, "", e, + e->e.alias.expr); + if (e->e.alias.offset) { + _print_expr (dstr, e->e.alias.offset, level, id, next); + dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"o\"];\n", indent, "", e, + e->e.alias.offset); } + + dstring_t *typestr = dstring_newstr(); + print_type_str (typestr, e->e.alias.type); + dasprintf (dstr, "%*se_%p [label=\"%s (%s)\\n%d\"];\n", indent, "", e, + "", typestr->str, e->line); + dstring_delete (typestr); } static void print_uexpr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) { int indent = level * 2 + 2; - dstring_t *typestr = dstring_newstr(); if (e->e.expr.op != 'g' && e->e.expr.e1) _print_expr (dstr, e->e.expr.e1, level, id, next); - if (e->e.expr.op == 'A') { - dstring_copystr (typestr, "\\n"); - print_type_str (typestr, e->e.expr.type); - } if (e->e.expr.op != 'r' || e->e.expr.e1) dasprintf (dstr, "%*se_%p -> \"e_%p\";\n", indent, "", e, e->e.expr.e1); - dasprintf (dstr, "%*se_%p [label=\"%s%s\\n%d\"];\n", indent, "", e, - get_op_string (e->e.expr.op), typestr->str, e->line); - dstring_delete (typestr); + dasprintf (dstr, "%*se_%p [label=\"%s\\n%d\"];\n", indent, "", e, + get_op_string (e->e.expr.op), e->line); } static void @@ -574,6 +580,7 @@ _print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) [ex_value] = print_value, [ex_compound] = print_compound, [ex_memset] = print_memset, + [ex_alias] = print_alias, }; int indent = level * 2 + 2; @@ -585,7 +592,7 @@ _print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) return; e->printid = id; - if ((int) e->type < 0 || e->type > ex_memset || !print_funcs[e->type]) { + if ((int) e->type < 0 || e->type >= ex_count || !print_funcs[e->type]) { dasprintf (dstr, "%*se_%p [label=\"(bad expr type)\\n%d\"];\n", indent, "", e, e->line); return; diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index d4f36d306..cb6e7585d 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -258,6 +258,8 @@ get_type (expr_t *e) return e->e.vector.type; case ex_selector: return &type_SEL; + case ex_alias: + return e->e.alias.type; case ex_count: internal_error (e, "invalid expression"); } @@ -315,7 +317,7 @@ cast_error (expr_t *e, type_t *t1, type_t *t2) print_type_str (s1, t1); print_type_str (s2, t2); - e = error (e, "cannot cast from %s to %s", s1->str, s2->str); + e = error (e, "cannot cast from %s to %s", s1->str, s2->str); dstring_delete (s1); dstring_delete (s2); return e; @@ -469,6 +471,12 @@ copy_expr (expr_t *e) n->e.memset.val = copy_expr (e->e.memset.val); n->e.memset.count = copy_expr (e->e.memset.count); return n; + case ex_alias: + n = new_expr (); + *n = *e; + n->e.alias.expr = copy_expr (e->e.alias.expr); + n->e.alias.offset = copy_expr (e->e.alias.offset); + return n; case ex_count: break; } @@ -875,9 +883,8 @@ new_short_expr (short short_val) int is_constant (expr_t *e) { - while ((e->type == ex_uexpr || e->type == ex_expr) - && e->e.expr.op == 'A') { - e = e->e.expr.e1; + while (e->type == ex_alias) { + e = e->e.alias.expr; } if (e->type == ex_nil || e->type == ex_value || e->type == ex_labelref || (e->type == ex_symbol && e->e.symbol->sy_type == sy_const) @@ -1231,15 +1238,14 @@ is_pointer_val (expr_t *e) expr_t * new_alias_expr (type_t *type, expr_t *expr) { - expr_t *alias; - - alias = new_unary_expr ('A', expr); - alias->e.expr.type = type; - //if (expr->type == ex_uexpr && expr->e.expr.op == 'A') - // bug (alias, "aliasing an alias expression"); - if (expr->type == ex_expr && expr->e.expr.op == 'A') { + if (expr->type == ex_alias) { return new_offset_alias_expr (type, expr, 0); } + + expr_t *alias = new_expr (); + alias->type = ex_alias; + alias->e.alias.type = type; + alias->e.alias.expr = expr; alias->file = expr->file; alias->line = expr->line; return alias; @@ -1248,18 +1254,24 @@ new_alias_expr (type_t *type, expr_t *expr) expr_t * new_offset_alias_expr (type_t *type, expr_t *expr, int offset) { - expr_t *alias; - - if (expr->type == ex_expr && expr->e.expr.op == 'A') { - expr_t *ofs_expr = expr->e.expr.e2; - expr = expr->e.expr.e1; + if (expr->type == ex_alias && expr->e.alias.offset) { + expr_t *ofs_expr = expr->e.alias.offset; if (!is_constant (ofs_expr)) { internal_error (ofs_expr, "non-constant offset for alias expr"); } offset += expr_integer (ofs_expr); + + if (expr->e.alias.expr->type == ex_alias) { + internal_error (expr, "alias expr of alias expr"); + } + expr = expr->e.alias.expr; } - alias = new_binary_expr ('A', expr, new_integer_expr (offset)); - alias->e.expr.type = type; + + expr_t *alias = new_expr (); + alias->type = ex_alias; + alias->e.alias.type = type; + alias->e.alias.expr = expr; + alias->e.alias.offset = new_integer_expr (offset); alias->file = expr->file; alias->line = expr->line; return alias; @@ -1576,9 +1588,27 @@ has_function_call (expr_t *e) case ex_uexpr: if (e->e.expr.op != 'g') return has_function_call (e->e.expr.e1); - default: return 0; + case ex_alias: + return has_function_call (e->e.alias.expr); + case ex_error: + case ex_state: + case ex_label: + case ex_labelref: + case ex_def: + case ex_symbol: + case ex_temp: + case ex_vector: + case ex_selector: + case ex_nil: + case ex_value: + case ex_compound: + case ex_memset: + return 0; + case ex_count: + break; } + internal_error (e, "invalid expression type"); } expr_t * @@ -1683,6 +1713,7 @@ unary_expr (int op, expr_t *e) case ex_bool: case ex_temp: case ex_vector: + case ex_alias: { expr_t *n = new_unary_expr (op, e); @@ -1766,6 +1797,7 @@ unary_expr (int op, expr_t *e) case ex_symbol: case ex_temp: case ex_vector: + case ex_alias: { expr_t *n = new_unary_expr (op, e); @@ -1842,6 +1874,7 @@ unary_expr (int op, expr_t *e) case ex_symbol: case ex_temp: case ex_vector: + case ex_alias: bitnot_expr: if (options.code.progsversion == PROG_ID_VERSION) { expr_t *n1 = new_integer_expr (-1); @@ -2364,16 +2397,6 @@ address_expr (expr_t *e1, expr_t *e2, type_t *t) e = e1->e.expr.e2; break; } - if (e1->e.expr.op == 'A') { - if (!t) - t = e1->e.expr.type; - if (e2) { - e2 = binary_expr ('+', e1->e.expr.e2, e2); - } else { - e2 = e1->e.expr.e2; - } - return address_expr (e1->e.expr.e1, e2, t); - } return error (e1, "invalid type for unary &"); case ex_uexpr: if (e1->e.expr.op == '.') { @@ -2384,11 +2407,6 @@ address_expr (expr_t *e1, expr_t *e2, type_t *t) } break; } - if (e1->e.expr.op == 'A') { - if (!t) - t = e1->e.expr.type; - return address_expr (e1->e.expr.e1, e2, t); - } return error (e1, "invalid type for unary &"); case ex_label: return new_label_ref (&e1->e.label); @@ -2396,6 +2414,18 @@ address_expr (expr_t *e1, expr_t *e2, type_t *t) e = new_unary_expr ('&', e1); e->e.expr.type = pointer_type (t); break; + case ex_alias: + if (!t) { + t = e1->e.alias.type; + } + if (e1->e.alias.offset) { + if (e2) { + e2 = binary_expr ('+', e1->e.alias.offset, e2); + } else { + e2 = e1->e.alias.offset; + } + } + return address_expr (e1->e.alias.expr, e2, t); default: return error (e1, "invalid type for unary &"); } @@ -2416,8 +2446,11 @@ address_expr (expr_t *e1, expr_t *e2, type_t *t) e = new_binary_expr ('&', e, e2); } } - if (e->type == ex_expr || e->type == ex_uexpr) + if (e->type == ex_expr || e->type == ex_uexpr) { e->e.expr.type = pointer_type (t); + } else if (e->type == ex_alias) { + e->e.alias.type = pointer_type (t); + } } } return e; diff --git a/tools/qfcc/source/expr_assign.c b/tools/qfcc/source/expr_assign.c index 7126b5545..80c95d1dc 100644 --- a/tools/qfcc/source/expr_assign.c +++ b/tools/qfcc/source/expr_assign.c @@ -112,17 +112,13 @@ is_lvalue (const expr_t *expr) if (expr->e.expr.op == '.') { return 1; } - if (expr->e.expr.op == 'A') { - return is_lvalue (expr->e.expr.e1); - } break; + case ex_alias: + return is_lvalue (expr->e.alias.expr); case ex_uexpr: if (expr->e.expr.op == '.') { return 1; } - if (expr->e.expr.op == 'A') { - return is_lvalue (expr->e.expr.e1); - } break; case ex_memset: case ex_compound: diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index 616dc7ac4..eeb310c59 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -970,12 +970,11 @@ binary_expr (int op, expr_t *e1, expr_t *e2) e1 = convert_vector (e1); // FIXME this is target-specific info and should not be in the // expression tree - if ((e1->type == ex_expr || e1->type == ex_uexpr) && e1->e.expr.op == 'A' - && is_call (e1->e.expr.e1)) { + if (e1->type == ex_alias && is_call (e1->e.alias.expr)) { // move the alias expression inside the block so the following check // can detect the call and move the temp assignment into the block - expr_t *block = e1->e.expr.e1; - e1->e.expr.e1 = block->e.block.result; + expr_t *block = e1->e.alias.expr; + e1->e.alias.expr = block->e.block.result; block->e.block.result = e1; e1 = block; } diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 0dfcebe88..b34b201f0 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1202,11 +1202,11 @@ expr_alias (sblock_t *sblock, expr_t *e, operand_t **op) def_t *def; int offset = 0; - if (e->type == ex_expr) { - offset = expr_integer (e->e.expr.e2); + if (e->e.alias.offset) { + offset = expr_integer (e->e.alias.offset); } - type = e->e.expr.type; - sblock = statement_subexpr (sblock, e->e.expr.e1, &aop); + type = e->e.alias.type; + sblock = statement_subexpr (sblock, e->e.alias.expr, &aop); if (type_compatible (aop->type, type)) { //FIXME type_compatible??? shouldn't that be type_size ==? if (offset) { @@ -1268,9 +1268,6 @@ expr_expr (sblock_t *sblock, expr_t *e, operand_t **op) case 'M': sblock = expr_move (sblock, e, op); break; - case 'A': - sblock = expr_alias (sblock, e, op); - break; default: opcode = convert_op (e->e.expr.op); if (!opcode) @@ -1338,9 +1335,6 @@ expr_uexpr (sblock_t *sblock, expr_t *e, operand_t **op) case '.': sblock = expr_deref (sblock, e, op); break; - case 'A': - sblock = expr_alias (sblock, e, op); - break; case 'C': sblock = expr_cast (sblock, e, op); break; @@ -1529,6 +1523,7 @@ statement_subexpr (sblock_t *sblock, expr_t *e, operand_t **op) [ex_nil] = expr_nil, [ex_value] = expr_value, [ex_selector] = expr_selector, + [ex_alias] = expr_alias, }; if (!e) { *op = 0; From da210db7207abc62de40bb4bb4f22c9c8ca3f4e7 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 8 Jan 2022 12:10:30 +0900 Subject: [PATCH 065/360] [qfcc] Fix some type aliasing bugs I have no idea why sorting out expression aliasing exposed these type aliasing bugs, but it did. All tests *build* again (and pass). --- tools/qfcc/source/expr.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index cb6e7585d..7f1424cb0 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1350,7 +1350,7 @@ append_expr (expr_t *block, expr_t *e) static symbol_t * get_struct_field (const type_t *t1, expr_t *e1, expr_t *e2) { - symtab_t *strct = t1->t.symtab; + symtab_t *strct = unalias_type(t1)->t.symtab; symbol_t *sym = e2->e.symbol;//FIXME need to check symbol_t *field; @@ -1375,7 +1375,7 @@ field_expr (expr_t *e1, expr_t *e2) t1 = get_type (e1); if (e1->type == ex_error) return e1; - if (t1->type == ev_entity) { + if (is_entity (t1)) { symbol_t *field = 0; if (e2->type == ex_symbol) @@ -1395,7 +1395,8 @@ field_expr (expr_t *e1, expr_t *e2) return e; } } - } else if (t1->type == ev_pointer) { + } else if (is_pointer (t1)) { + t1 = unalias_type (t1); if (is_struct (t1->t.fldptr.type)) { symbol_t *field; @@ -1423,8 +1424,7 @@ field_expr (expr_t *e1, expr_t *e2) e->e.expr.type = pointer_type (ivar->type); return unary_expr ('.', e); } - } else if (t1->type == ev_vector || t1->type == ev_quat - || is_struct (t1)) { + } else if (is_vector (t1) || is_quaternion(t1) || is_struct (t1)) { symbol_t *field; field = get_struct_field (t1, e1, e2); @@ -2292,7 +2292,7 @@ array_expr (expr_t *array, expr_t *index) ind = expr_short (index); if (is_integer_val (index)) ind = expr_integer (index); - if (array_type->t.func.num_params + if (is_array (array_type) && is_constant (index) && (ind < array_type->t.array.base || ind - array_type->t.array.base >= array_type->t.array.size)) @@ -2715,7 +2715,7 @@ cast_expr (type_t *dstType, expr_t *e) dstType = (type_t *) unalias_type (dstType); //FIXME cast srcType = get_type (e); - if (dstType == srcType) + if (dstType == unalias_type(srcType)) return e; if ((dstType == type_default && is_enum (srcType)) From cf8061c4d36e99f82bae7ff8d062a04ff975a78c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 8 Jan 2022 12:14:27 +0900 Subject: [PATCH 066/360] [qfcc] Mark opcode_get as pure Because gcc told me to :P --- tools/qfcc/include/opcodes.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/qfcc/include/opcodes.h b/tools/qfcc/include/opcodes.h index d8aa393ea..2966235e6 100644 --- a/tools/qfcc/include/opcodes.h +++ b/tools/qfcc/include/opcodes.h @@ -36,7 +36,7 @@ typedef struct instruction_s instruction_t; struct operand_s; -pr_ushort_t opcode_get (instruction_t *inst); +pr_ushort_t opcode_get (instruction_t *inst) __attribute__((pure)); instruction_t *opcode_find (const char *name, struct operand_s *op_a, struct operand_s *op_b, struct operand_s *op_c); void opcode_init (void); From fa482e8ee5a8bd5e2e6bc03062bc801b51dd9dbf Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 8 Jan 2022 16:52:24 +0900 Subject: [PATCH 067/360] [qfcc] Give address expressions their own type Definitely a pain to get working after the switch, but definitely worth the effort. Still exposing type aliasing bugs. --- tools/qfcc/include/expr.h | 10 +++++ tools/qfcc/include/expr_names.h | 3 +- tools/qfcc/source/constfold.c | 8 ++-- tools/qfcc/source/dot_expr.c | 22 +++++++++++ tools/qfcc/source/expr.c | 65 ++++++++++++++++++++------------- tools/qfcc/source/expr_assign.c | 2 + tools/qfcc/source/method.c | 4 +- tools/qfcc/source/statements.c | 30 ++++++++------- 8 files changed, 99 insertions(+), 45 deletions(-) diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 817c82e7b..5debb0058 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -213,6 +213,12 @@ typedef struct { struct expr_s *offset; ///< offset for alias } ex_alias_t; +typedef struct { + struct type_s *type; ///< pointer type + struct expr_s *lvalue; ///< the lvalue being addressed + struct expr_s *offset; ///< offset from the address +} ex_address_t; + #define POINTER_VAL(p) (((p).def ? (p).def->offset : 0) + (p).val) typedef struct expr_s { @@ -240,6 +246,7 @@ typedef struct expr_s { element_chain_t compound; ///< compound initializer ex_memset_t memset; ///< memset expr params ex_alias_t alias; ///< alias expr params + ex_address_t address; ///< alias expr params struct type_s *nil; ///< type for nil if known } e; } expr_t; @@ -654,6 +661,9 @@ expr_t *new_ret_expr (struct type_s *type); expr_t *new_alias_expr (struct type_s *type, expr_t *expr); expr_t *new_offset_alias_expr (struct type_s *type, expr_t *expr, int offset); +expr_t *new_address_expr (struct type_s *lvtype, expr_t *lvalue, + expr_t *offset); + /** Create an expression of the correct type that references the specified parameter slot. diff --git a/tools/qfcc/include/expr_names.h b/tools/qfcc/include/expr_names.h index a37355bcc..0842c2b2b 100644 --- a/tools/qfcc/include/expr_names.h +++ b/tools/qfcc/include/expr_names.h @@ -1,5 +1,5 @@ /* - expr.h + expr_names.h expression construction and manipulations @@ -55,5 +55,6 @@ EX_EXPR(value) ///< constant value (::ex_value_t) EX_EXPR(compound) ///< compound initializer EX_EXPR(memset) ///< memset needs three params... EX_EXPR(alias) ///< view expression as different type (::ex_alias_t) +EX_EXPR(address) ///< address of an lvalue expression (::ex_address_t) ///@} diff --git a/tools/qfcc/source/constfold.c b/tools/qfcc/source/constfold.c index 497f51642..76c8c74fc 100644 --- a/tools/qfcc/source/constfold.c +++ b/tools/qfcc/source/constfold.c @@ -568,7 +568,7 @@ do_op_entity (int op, expr_t *e, expr_t *e1, expr_t *e2) { type_t *type = get_type (e2); - if ((op == '.' || op == '&') && type->type == ev_field) { + if (op == '.' && type->type == ev_field) { return e; } if (op == EQ || op == NE) { @@ -617,7 +617,7 @@ static expr_t * do_op_pointer (int op, expr_t *e, expr_t *e1, expr_t *e2) { type_t *type; - static int valid[] = {'=', '-', '&', 'M', '.', EQ, NE, 0}; + static int valid[] = {'=', '-', 'M', '.', EQ, NE, 0}; if (is_integral (type = get_type (e2)) && (op == '-' || op == '+')) { // pointer arithmetic @@ -647,10 +647,10 @@ do_op_pointer (int op, expr_t *e, expr_t *e1, expr_t *e2) else e->e.expr.type = &type_float; } - if (op != '.' && op != '&' && op != 'M' + if (op != '.' && op != 'M' && extract_type (e1) != extract_type (e2)) return type_mismatch (e1, e2, op); - if ((op == '.' || op == '&') && is_uinteger(get_type (e2))) + if (op == '.' && is_uinteger(get_type (e2))) e->e.expr.e2 = cf_cast_expr (&type_integer, e2); return e; } diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index feaf3defd..32ceea58c 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -338,6 +338,27 @@ print_alias (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) dstring_delete (typestr); } +static void +print_address (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) +{ + int indent = level * 2 + 2; + + _print_expr (dstr, e->e.alias.expr, level, id, next); + dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"&\"];\n", indent, "", e, + e->e.alias.expr); + if (e->e.alias.offset) { + _print_expr (dstr, e->e.alias.offset, level, id, next); + dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"+\"];\n", indent, "", e, + e->e.alias.offset); + } + + dstring_t *typestr = dstring_newstr(); + print_type_str (typestr, e->e.alias.type); + dasprintf (dstr, "%*se_%p [label=\"%s (%s)\\n%d\"];\n", indent, "", e, + "&", typestr->str, e->line); + dstring_delete (typestr); +} + static void print_uexpr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) { @@ -581,6 +602,7 @@ _print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) [ex_compound] = print_compound, [ex_memset] = print_memset, [ex_alias] = print_alias, + [ex_address] = print_address, }; int indent = level * 2 + 2; diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 7f1424cb0..257eeed17 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -260,6 +260,8 @@ get_type (expr_t *e) return &type_SEL; case ex_alias: return e->e.alias.type; + case ex_address: + return e->e.address.type; case ex_count: internal_error (e, "invalid expression"); } @@ -477,6 +479,12 @@ copy_expr (expr_t *e) n->e.alias.expr = copy_expr (e->e.alias.expr); n->e.alias.offset = copy_expr (e->e.alias.offset); return n; + case ex_address: + n = new_expr (); + *n = *e; + n->e.address.lvalue = copy_expr (e->e.address.lvalue); + n->e.address.offset = copy_expr (e->e.address.offset); + return n; case ex_count: break; } @@ -1277,6 +1285,17 @@ new_offset_alias_expr (type_t *type, expr_t *expr, int offset) return alias; } +expr_t * +new_address_expr (type_t *lvtype, expr_t *lvalue, expr_t *offset) +{ + expr_t *addr = new_expr (); + addr->type = ex_address; + addr->e.address.type = pointer_type (lvtype); + addr->e.address.lvalue = lvalue; + addr->e.address.offset = offset; + return addr; +} + static expr_t * param_expr (const char *name, type_t *type) { @@ -1406,8 +1425,7 @@ field_expr (expr_t *e1, expr_t *e2) e2->type = ex_value; e2->e.value = new_short_val (field->s.offset); - e = new_binary_expr ('&', e1, e2); - e->e.expr.type = pointer_type (field->type); + e = new_address_expr (field->type, e1, e2); return unary_expr ('.', e); } else if (is_class (t1->t.fldptr.type)) { class_t *class = t1->t.fldptr.type->t.class; @@ -1420,8 +1438,7 @@ field_expr (expr_t *e1, expr_t *e2) return new_error_expr (); e2->type = ex_value; e2->e.value = new_short_val (ivar->s.offset); - e = new_binary_expr ('&', e1, e2); - e->e.expr.type = pointer_type (ivar->type); + e = new_address_expr (ivar->type, e1, e2); return unary_expr ('.', e); } } else if (is_vector (t1) || is_quaternion(t1) || is_struct (t1)) { @@ -1591,6 +1608,8 @@ has_function_call (expr_t *e) return 0; case ex_alias: return has_function_call (e->e.alias.expr); + case ex_address: + return has_function_call (e->e.address.lvalue); case ex_error: case ex_state: case ex_label: @@ -1735,6 +1754,7 @@ unary_expr (int op, expr_t *e) return n; } case ex_nil: + case ex_address: return error (e, "invalid type for unary -"); case ex_count: internal_error (e, "invalid expression"); @@ -1798,6 +1818,7 @@ unary_expr (int op, expr_t *e) case ex_temp: case ex_vector: case ex_alias: + case ex_address: { expr_t *n = new_unary_expr (op, e); @@ -1890,6 +1911,7 @@ bitnot_expr: return n; } case ex_nil: + case ex_address: return error (e, "invalid type for unary ~"); case ex_count: internal_error (e, "invalid expression"); @@ -2312,9 +2334,7 @@ array_expr (expr_t *array, expr_t *index) e = address_expr (array, index, array_type->t.array.type); } else { if (!is_short_val (index) || expr_short (index)) { - e = new_binary_expr ('&', array, index); - //e->e.expr.type = array_type->aux_type; - e->e.expr.type = array_type; + e = new_address_expr (array_type->t.array.type, array, index); } else { e = array; } @@ -2382,9 +2402,8 @@ address_expr (expr_t *e1, expr_t *e2, type_t *t) return error (e1, "invalid type for unary &"); case ex_expr: if (e1->e.expr.op == '.') { - e = e1; - e->e.expr.op = '&'; - e->e.expr.type = pointer_type (e->e.expr.type); + e = new_address_expr (e1->e.expr.type, + e1->e.expr.e1, e1->e.expr.e2); break; } if (e1->e.expr.op == 'm') { @@ -2402,8 +2421,7 @@ address_expr (expr_t *e1, expr_t *e2, type_t *t) if (e1->e.expr.op == '.') { e = e1->e.expr.e1; if (e->type == ex_expr && e->e.expr.op == '.') { - e->e.expr.type = pointer_type (e->e.expr.type); - e->e.expr.op = '&'; + e = new_address_expr (e->e.expr.type, e->e.expr.e1, e->e.expr.e2); } break; } @@ -2411,8 +2429,7 @@ address_expr (expr_t *e1, expr_t *e2, type_t *t) case ex_label: return new_label_ref (&e1->e.label); case ex_temp: - e = new_unary_expr ('&', e1); - e->e.expr.type = pointer_type (t); + e = new_address_expr (t, e1, 0); break; case ex_alias: if (!t) { @@ -2438,19 +2455,17 @@ address_expr (expr_t *e1, expr_t *e2, type_t *t) def_t *def = e->e.value->v.pointer.def; e->e.value = new_pointer_val (base + offset, t, def, 0); } else { - if (!is_short_val (e2) || expr_short (e2)) { - if (e->type == ex_expr && e->e.expr.op == '&') { - e = new_binary_expr ('&', e->e.expr.e1, - binary_expr ('+', e->e.expr.e2, e2)); - } else { - e = new_binary_expr ('&', e, e2); - } + expr_t *offset = 0; + if (e->type == ex_address) { + offset = e->e.address.offset; + e1 = e->e.address.lvalue; + } else { + e1 = e; } - if (e->type == ex_expr || e->type == ex_uexpr) { - e->e.expr.type = pointer_type (t); - } else if (e->type == ex_alias) { - e->e.alias.type = pointer_type (t); + if (offset) { + e2 = binary_expr ('+', offset, e2); } + e = new_address_expr (t, e1, e2); } } return e; diff --git a/tools/qfcc/source/expr_assign.c b/tools/qfcc/source/expr_assign.c index 80c95d1dc..eae003bc9 100644 --- a/tools/qfcc/source/expr_assign.c +++ b/tools/qfcc/source/expr_assign.c @@ -115,6 +115,8 @@ is_lvalue (const expr_t *expr) break; case ex_alias: return is_lvalue (expr->e.alias.expr); + case ex_address: + return 0; case ex_uexpr: if (expr->e.expr.op == '.') { return 1; diff --git a/tools/qfcc/source/method.c b/tools/qfcc/source/method.c index 55a4f2344..134f1cc64 100644 --- a/tools/qfcc/source/method.c +++ b/tools/qfcc/source/method.c @@ -486,8 +486,8 @@ get_selector (expr_t *sel) if (sel->type == ex_selector) { return sel->e.selector.sel; } - if (sel->type != ex_expr && sel->e.expr.op != '&' - && !is_SEL(sel->e.expr.type)) { + if (sel->type != ex_address && !sel->e.address.offset + && !is_SEL(sel->e.address.type)) { error (sel, "not a selector"); return 0; } diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index b34b201f0..205c22c3e 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -744,8 +744,11 @@ expr_address (sblock_t *sblock, expr_t *e, operand_t **op) { statement_t *s; s = new_statement (st_expr, "&", e); - sblock = statement_subexpr (sblock, e->e.expr.e1, &s->opa); - s->opc = temp_operand (e->e.expr.type, e); + sblock = statement_subexpr (sblock, e->e.address.lvalue, &s->opa); + if (e->e.address.offset) { + sblock = statement_subexpr (sblock, e->e.address.offset, &s->opb); + } + s->opc = temp_operand (e->e.address.type, e); sblock_add_statement (sblock, s); *(op) = s->opc; return sblock; @@ -960,9 +963,12 @@ dereference_dst: // to get the pointer and switch to storep instructions. dst_expr = expr_file_line (address_expr (dst_expr, 0, 0), e); opcode = ".="; // FIXME find a nicer representation (lose strings?) - if (dst_expr->type == ex_expr && !is_const_ptr (dst_expr->e.expr.e1)) { - sblock = statement_subexpr (sblock, dst_expr->e.expr.e1, &dst); - sblock = statement_subexpr (sblock, dst_expr->e.expr.e2, &ofs); + if (dst_expr->type == ex_address && dst_expr->e.address.offset + && !is_const_ptr (dst_expr->e.address.lvalue)) { + sblock = statement_subexpr (sblock, + dst_expr->e.address.lvalue, &dst); + sblock = statement_subexpr (sblock, + dst_expr->e.address.offset, &ofs); } else { sblock = statement_subexpr (sblock, dst_expr, &dst); ofs = 0; @@ -1127,17 +1133,17 @@ expr_deref (sblock_t *sblock, expr_t *deref, operand_t **op) expr_t *e; e = deref->e.expr.e1; - if (e->type == ex_uexpr && e->e.expr.op == '&' - && e->e.expr.e1->type == ex_symbol) { + if (e->type == ex_address && !e->e.address.offset + && e->e.address.lvalue->type == ex_symbol) { if (e->e.expr.e1->e.symbol->sy_type != sy_var) internal_error (e, "address of non-var"); *op = def_operand (e->e.expr.e1->e.symbol->s.def, type, e); - } else if (e->type == ex_expr && e->e.expr.op == '&') { + } else if (e->type == ex_address && e->e.address.offset) { statement_t *s; operand_t *ptr = 0; operand_t *offs = 0; - sblock = statement_subexpr (sblock, e->e.expr.e1, &ptr); - sblock = statement_subexpr (sblock, e->e.expr.e2, &offs); + sblock = statement_subexpr (sblock, e->e.address.lvalue, &ptr); + sblock = statement_subexpr (sblock, e->e.address.offset, &offs); if (!*op) *op = temp_operand (type, e); if (low_level_type (type) == ev_void) { @@ -1329,9 +1335,6 @@ expr_uexpr (sblock_t *sblock, expr_t *e, operand_t **op) statement_t *s; switch (e->e.expr.op) { - case '&': - sblock = expr_address (sblock, e, op); - break; case '.': sblock = expr_deref (sblock, e, op); break; @@ -1524,6 +1527,7 @@ statement_subexpr (sblock_t *sblock, expr_t *e, operand_t **op) [ex_value] = expr_value, [ex_selector] = expr_selector, [ex_alias] = expr_alias, + [ex_address] = expr_address, }; if (!e) { *op = 0; From d14f695c68c54e3683dec1de5cbb29d0005059fe Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 8 Jan 2022 16:54:08 +0900 Subject: [PATCH 068/360] [qfcc] Fix another type aliasing bug This one exposed by the address expression cleanup. --- tools/qfcc/source/expr.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 257eeed17..f8adf1351 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1921,7 +1921,8 @@ bitnot_expr: if (extract_type (e) != ev_pointer) return error (e, "invalid type for unary ."); e = new_unary_expr ('.', e); - e->e.expr.type = get_type (e->e.expr.e1)->t.fldptr.type; + const type_t *t = unalias_type (get_type (e->e.expr.e1)); + e->e.expr.type = t->t.fldptr.type; return e; case '+': if (!is_math (get_type (e))) From 65b6c366c33533213fcf6fbad67df8b0847f8a03 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 8 Jan 2022 18:44:29 +0900 Subject: [PATCH 069/360] [qfcc] Give assignment expressions their own type This is getting easier (know where to look, I guess). Nicely, I found the source of those weird type aliasing bugs :) --- tools/qfcc/include/expr.h | 7 +++ tools/qfcc/include/expr_names.h | 1 + tools/qfcc/source/constfold.c | 82 ++++++++++++--------------------- tools/qfcc/source/dot_expr.c | 30 +++++++++--- tools/qfcc/source/expr.c | 24 ++++++++++ tools/qfcc/source/expr_assign.c | 6 +-- tools/qfcc/source/expr_bool.c | 8 ++-- tools/qfcc/source/statements.c | 31 +++++++------ 8 files changed, 109 insertions(+), 80 deletions(-) diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 5debb0058..5773d834e 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -219,6 +219,11 @@ typedef struct { struct expr_s *offset; ///< offset from the address } ex_address_t; +typedef struct { + struct expr_s *dst; ///< destination of assignment + struct expr_s *src; ///< source of assignment +} ex_assign_t; + #define POINTER_VAL(p) (((p).def ? (p).def->offset : 0) + (p).val) typedef struct expr_s { @@ -247,6 +252,7 @@ typedef struct expr_s { ex_memset_t memset; ///< memset expr params ex_alias_t alias; ///< alias expr params ex_address_t address; ///< alias expr params + ex_assign_t assign; ///< assignment expr params struct type_s *nil; ///< type for nil if known } e; } expr_t; @@ -663,6 +669,7 @@ expr_t *new_offset_alias_expr (struct type_s *type, expr_t *expr, int offset); expr_t *new_address_expr (struct type_s *lvtype, expr_t *lvalue, expr_t *offset); +expr_t *new_assign_expr (expr_t *dst, expr_t *src); /** Create an expression of the correct type that references the specified parameter slot. diff --git a/tools/qfcc/include/expr_names.h b/tools/qfcc/include/expr_names.h index 0842c2b2b..25ebfe07c 100644 --- a/tools/qfcc/include/expr_names.h +++ b/tools/qfcc/include/expr_names.h @@ -56,5 +56,6 @@ EX_EXPR(compound) ///< compound initializer EX_EXPR(memset) ///< memset needs three params... EX_EXPR(alias) ///< view expression as different type (::ex_alias_t) EX_EXPR(address) ///< address of an lvalue expression (::ex_address_t) +EX_EXPR(assign) ///< assignment of src expr to dst expr ///@} diff --git a/tools/qfcc/source/constfold.c b/tools/qfcc/source/constfold.c index 76c8c74fc..6bc564e4a 100644 --- a/tools/qfcc/source/constfold.c +++ b/tools/qfcc/source/constfold.c @@ -85,7 +85,7 @@ do_op_string (int op, expr_t *e, expr_t *e1, expr_t *e2) { const char *s1, *s2; static dstring_t *temp_str; - static int valid[] = {'=', '+', LT, GT, LE, GE, EQ, NE, 0}; + static int valid[] = {'+', LT, GT, LE, GE, EQ, NE, 0}; if (!valid_op (op, valid)) return error (e1, "invalid operand for string"); @@ -99,7 +99,7 @@ do_op_string (int op, expr_t *e, expr_t *e1, expr_t *e2) e->e.expr.type = &type_string; } - if (op == '=' || !is_constant (e1) || !is_constant (e2)) + if (!is_constant (e1) || !is_constant (e2)) return e; s1 = expr_string (e1); @@ -220,27 +220,18 @@ do_op_float (int op, expr_t *e, expr_t *e1, expr_t *e2) expr_t *conv; type_t *type = &type_float; static int valid[] = { - '=', '+', '-', '*', '/', '&', '|', '^', '%', + '+', '-', '*', '/', '&', '|', '^', '%', SHL, SHR, AND, OR, LT, GT, LE, GE, EQ, NE, 0 }; if (!valid_op (op, valid)) return error (e1, "invalid operator for float"); - if (op == '=') { - if (!is_float(type = get_type (e1))) { - //FIXME optimize casting a constant - e->e.expr.e2 = e2 = cf_cast_expr (type, e2); - } else if ((conv = convert_to_float (e2)) != e2) { - e->e.expr.e2 = e2 = conv; - } - } else { - if ((conv = convert_to_float (e1)) != e1) { - e->e.expr.e1 = e1 = conv; - } - if ((conv = convert_to_float (e2)) != e2) { - e->e.expr.e2 = e2 = conv; - } + if ((conv = convert_to_float (e1)) != e1) { + e->e.expr.e1 = e1 = conv; + } + if ((conv = convert_to_float (e2)) != e2) { + e->e.expr.e2 = e2 = conv; } if (is_compare (op) || is_logic (op)) { if (options.code.progsversion > PROG_ID_VERSION) @@ -271,7 +262,7 @@ do_op_float (int op, expr_t *e, expr_t *e1, expr_t *e2) if (op == '-' && is_constant (e2) && expr_float (e2) == 0) return e1; - if (op == '=' || !is_constant (e1) || !is_constant (e2)) + if (!is_constant (e1) || !is_constant (e2)) return e; f1 = expr_float (e1); @@ -349,27 +340,18 @@ do_op_double (int op, expr_t *e, expr_t *e1, expr_t *e2) expr_t *conv; type_t *type = &type_double; static int valid[] = { - '=', '+', '-', '*', '/', '%', + '+', '-', '*', '/', '%', LT, GT, LE, GE, EQ, NE, 0 }; if (!valid_op (op, valid)) return error (e1, "invalid operator for double"); - if (op == '=') { - if (!is_double(type = get_type (e1))) { - //FIXME optimize casting a constant - e->e.expr.e2 = e2 = cf_cast_expr (type, e2); - } else if ((conv = convert_to_double (e2)) != e2) { - e->e.expr.e2 = e2 = conv; - } - } else { - if ((conv = convert_to_double (e1)) != e1) { - e->e.expr.e1 = e1 = conv; - } - if ((conv = convert_to_double (e2)) != e2) { - e->e.expr.e2 = e2 = conv; - } + if ((conv = convert_to_double (e1)) != e1) { + e->e.expr.e1 = e1 = conv; + } + if ((conv = convert_to_double (e2)) != e2) { + e->e.expr.e2 = e2 = conv; } if (is_compare (op) || is_logic (op)) { type = &type_integer; @@ -397,7 +379,7 @@ do_op_double (int op, expr_t *e, expr_t *e1, expr_t *e2) if (op == '-' && is_constant (e2) && expr_double (e2) == 0) return e1; - if (op == '=' || !is_constant (e1) || !is_constant (e2)) + if (!is_constant (e1) || !is_constant (e2)) return e; d1 = expr_double (e1); @@ -452,7 +434,7 @@ do_op_vector (int op, expr_t *e, expr_t *e1, expr_t *e2) { const float *v1, *v2; vec3_t v, float_vec; - static int valid[] = {'=', '+', '-', '*', EQ, NE, 0}; + static int valid[] = {'+', '-', '*', EQ, NE, 0}; expr_t *t; if (!is_vector(get_type (e1))) { @@ -510,7 +492,7 @@ do_op_vector (int op, expr_t *e, expr_t *e1, expr_t *e2) if (op == '-' && is_constant (e2) && VectorIsZero (expr_vector (e2))) return e1; - if (op == '=' || !is_constant (e1) || !is_constant (e2)) + if (!is_constant (e1) || !is_constant (e2)) return e; if (is_float_val (e1)) { @@ -578,7 +560,7 @@ do_op_entity (int op, expr_t *e, expr_t *e1, expr_t *e2) e->e.expr.type = &type_float; return e; } - if (op != '=' || !is_entity(type)) + if (!is_entity(type)) return error (e1, "invalid operator for entity"); e->e.expr.type = &type_entity; return e; @@ -587,10 +569,7 @@ do_op_entity (int op, expr_t *e, expr_t *e1, expr_t *e2) static expr_t * do_op_field (int op, expr_t *e, expr_t *e1, expr_t *e2) { - if (op != '=') - return error (e1, "invalid operator for field"); - e->e.expr.type = &type_field; - return e; + return error (e1, "invalid operator for field"); } static expr_t * @@ -607,17 +586,14 @@ do_op_func (int op, expr_t *e, expr_t *e1, expr_t *e2) e->e.expr.type = &type_float; return e; } - if (op != '=') - return error (e1, "invalid operator for func"); - e->e.expr.type = &type_function; - return e; + return error (e1, "invalid operator for func"); } static expr_t * do_op_pointer (int op, expr_t *e, expr_t *e1, expr_t *e2) { type_t *type; - static int valid[] = {'=', '-', 'M', '.', EQ, NE, 0}; + static int valid[] = {'-', 'M', '.', EQ, NE, 0}; if (is_integral (type = get_type (e2)) && (op == '-' || op == '+')) { // pointer arithmetic @@ -682,7 +658,7 @@ do_op_quaternion (int op, expr_t *e, expr_t *e1, expr_t *e2) { const float *q1, *q2; quat_t q, float_quat; - static int valid[] = {'=', '+', '-', '*', EQ, NE, 0}; + static int valid[] = {'+', '-', '*', EQ, NE, 0}; expr_t *t; if (!is_quaternion(get_type (e1))) { @@ -731,7 +707,7 @@ do_op_quaternion (int op, expr_t *e, expr_t *e1, expr_t *e2) if (op == '-' && is_constant (e2) && QuatIsZero (expr_quaternion (e2))) return e1; - if (op == '=' || !is_constant (e1) || !is_constant (e2)) + if (!is_constant (e1) || !is_constant (e2)) return e; if (is_float_val (e1)) { @@ -793,7 +769,7 @@ do_op_integer (int op, expr_t *e, expr_t *e1, expr_t *e2) int isval1 = 0, isval2 = 0; int val1 = 0, val2 = 0; static int valid[] = { - '=', '+', '-', '*', '/', '&', '|', '^', '%', + '+', '-', '*', '/', '&', '|', '^', '%', SHL, SHR, AND, OR, LT, GT, LE, GE, EQ, NE, 0 }; @@ -848,7 +824,7 @@ do_op_integer (int op, expr_t *e, expr_t *e1, expr_t *e2) if (op == '-' && isval2 && val2 == 0) return e1; - if (op == '=' || !isval1 || !isval2) + if (!isval1 || !isval2) return e; switch (op) { @@ -927,7 +903,7 @@ do_op_short (int op, expr_t *e, expr_t *e1, expr_t *e2) { short i1, i2; static int valid[] = { - '=', '+', '-', '*', '/', '&', '|', '^', '%', + '+', '-', '*', '/', '&', '|', '^', '%', SHL, SHR, AND, OR, LT, GT, LE, GE, EQ, NE, 0 }; @@ -943,7 +919,7 @@ do_op_short (int op, expr_t *e, expr_t *e1, expr_t *e2) e->e.expr.type = &type_short; } - if (op == '=' || !is_constant (e1) || !is_constant (e2)) + if (!is_constant (e1) || !is_constant (e2)) return e; i1 = expr_short (e1); @@ -1019,7 +995,7 @@ do_op_struct (int op, expr_t *e, expr_t *e1, expr_t *e2) { type_t *type; - if (op != '=' && op != 'm') + if (op != 'm') return error (e1, "invalid operator for struct"); if ((type = get_type (e1)) != get_type (e2)) return type_mismatch (e1, e2, op); diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index 32ceea58c..008c99651 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -75,7 +75,6 @@ get_op_string (int op) case GE: return ">="; case LT: return "<"; case GT: return ">"; - case '=': return "="; case '+': return "+"; case '-': return "-"; case '*': return "*"; @@ -343,22 +342,38 @@ print_address (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) { int indent = level * 2 + 2; - _print_expr (dstr, e->e.alias.expr, level, id, next); + _print_expr (dstr, e->e.address.lvalue, level, id, next); dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"&\"];\n", indent, "", e, - e->e.alias.expr); - if (e->e.alias.offset) { - _print_expr (dstr, e->e.alias.offset, level, id, next); + e->e.address.lvalue); + if (e->e.address.offset) { + _print_expr (dstr, e->e.address.offset, level, id, next); dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"+\"];\n", indent, "", e, - e->e.alias.offset); + e->e.address.offset); } dstring_t *typestr = dstring_newstr(); - print_type_str (typestr, e->e.alias.type); + print_type_str (typestr, e->e.address.type); dasprintf (dstr, "%*se_%p [label=\"%s (%s)\\n%d\"];\n", indent, "", e, "&", typestr->str, e->line); dstring_delete (typestr); } +static void +print_assign (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) +{ + int indent = level * 2 + 2; + + _print_expr (dstr, e->e.assign.dst, level, id, next); + dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"lval\"];\n", indent, "", e, + e->e.assign.dst); + _print_expr (dstr, e->e.assign.src, level, id, next); + dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"rval\"];\n", indent, "", e, + e->e.assign.src); + + dasprintf (dstr, "%*se_%p [label=\"%s\\n%d\"];\n", indent, "", e, + "=", e->line); +} + static void print_uexpr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) { @@ -603,6 +618,7 @@ _print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) [ex_memset] = print_memset, [ex_alias] = print_alias, [ex_address] = print_address, + [ex_assign] = print_assign, }; int indent = level * 2 + 2; diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index f8adf1351..a67b1e3f1 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -262,6 +262,8 @@ get_type (expr_t *e) return e->e.alias.type; case ex_address: return e->e.address.type; + case ex_assign: + return get_type (e->e.assign.dst); case ex_count: internal_error (e, "invalid expression"); } @@ -485,6 +487,12 @@ copy_expr (expr_t *e) n->e.address.lvalue = copy_expr (e->e.address.lvalue); n->e.address.offset = copy_expr (e->e.address.offset); return n; + case ex_assign: + n = new_expr (); + *n = *e; + n->e.assign.dst = copy_expr (e->e.assign.dst); + n->e.assign.src = copy_expr (e->e.assign.src); + return n; case ex_count: break; } @@ -1296,6 +1304,16 @@ new_address_expr (type_t *lvtype, expr_t *lvalue, expr_t *offset) return addr; } +expr_t * +new_assign_expr (expr_t *dst, expr_t *src) +{ + expr_t *addr = new_expr (); + addr->type = ex_assign; + addr->e.assign.dst = dst; + addr->e.assign.src = src; + return addr; +} + static expr_t * param_expr (const char *name, type_t *type) { @@ -1610,6 +1628,9 @@ has_function_call (expr_t *e) return has_function_call (e->e.alias.expr); case ex_address: return has_function_call (e->e.address.lvalue); + case ex_assign: + return (has_function_call (e->e.assign.dst) + || has_function_call (e->e.assign.src)); case ex_error: case ex_state: case ex_label: @@ -1733,6 +1754,7 @@ unary_expr (int op, expr_t *e) case ex_temp: case ex_vector: case ex_alias: + case ex_assign: { expr_t *n = new_unary_expr (op, e); @@ -1819,6 +1841,7 @@ unary_expr (int op, expr_t *e) case ex_vector: case ex_alias: case ex_address: + case ex_assign: { expr_t *n = new_unary_expr (op, e); @@ -1896,6 +1919,7 @@ unary_expr (int op, expr_t *e) case ex_temp: case ex_vector: case ex_alias: + case ex_assign: bitnot_expr: if (options.code.progsversion == PROG_ID_VERSION) { expr_t *n1 = new_integer_expr (-1); diff --git a/tools/qfcc/source/expr_assign.c b/tools/qfcc/source/expr_assign.c index eae003bc9..24ce2e349 100644 --- a/tools/qfcc/source/expr_assign.c +++ b/tools/qfcc/source/expr_assign.c @@ -117,6 +117,8 @@ is_lvalue (const expr_t *expr) return is_lvalue (expr->e.alias.expr); case ex_address: return 0; + case ex_assign: + return 0; case ex_uexpr: if (expr->e.expr.op == '.') { return 1; @@ -283,7 +285,6 @@ is_memset (expr_t *e) expr_t * assign_expr (expr_t *dst, expr_t *src) { - int op = '='; expr_t *expr; type_t *dst_type, *src_type; @@ -355,7 +356,6 @@ assign_expr (expr_t *dst, expr_t *src) convert_nil (src, dst_type); } - expr = new_binary_expr (op, dst, src); - expr->e.expr.type = dst_type; + expr = new_assign_expr (dst, src); return expr; } diff --git a/tools/qfcc/source/expr_bool.c b/tools/qfcc/source/expr_bool.c index 83c202692..3861951db 100644 --- a/tools/qfcc/source/expr_bool.c +++ b/tools/qfcc/source/expr_bool.c @@ -249,16 +249,16 @@ convert_bool (expr_t *e, int block) { expr_t *b; - if (e->type == ex_expr && e->e.expr.op == '=') { + if (e->type == ex_assign) { expr_t *src; if (!e->paren && options.warnings.precedence) warning (e, "suggest parentheses around assignment " "used as truth value"); - src = e->e.expr.e2; + src = e->e.assign.src; if (src->type == ex_block) { src = new_temp_def_expr (get_type (src)); - e = new_binary_expr (e->e.expr.op, e->e.expr.e1, - assign_expr (src, e->e.expr.e2)); + e = new_assign_expr (e->e.assign.dst, + assign_expr (src, e->e.assign.src)); } b = convert_bool (src, 1); if (b->type == ex_error) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 205c22c3e..7180dc205 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -574,7 +574,6 @@ convert_op (int op) case GE: return ">="; case LT: return "<"; case GT: return ">"; - case '=': return "="; case '+': return "+"; case '-': return "-"; case '*': return "*"; @@ -819,8 +818,8 @@ static sblock_t * expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) { statement_t *s; - expr_t *dst_expr = e->e.expr.e1; - expr_t *src_expr = e->e.expr.e2; + expr_t *dst_expr = e->e.assign.dst; + expr_t *src_expr = e->e.assign.src; type_t *dst_type = get_type (dst_expr); type_t *src_type = get_type (src_expr); unsigned count; @@ -912,16 +911,16 @@ static sblock_t * expr_assign (sblock_t *sblock, expr_t *e, operand_t **op) { statement_t *s; - expr_t *src_expr = e->e.expr.e2; - expr_t *dst_expr = e->e.expr.e1; + expr_t *src_expr = e->e.assign.src; + expr_t *dst_expr = e->e.assign.dst; type_t *dst_type = get_type (dst_expr); operand_t *src = 0; operand_t *dst = 0; operand_t *ofs = 0; - const char *opcode = convert_op (e->e.expr.op); + const char *opcode = "="; st_type_t type; - if (src_expr->type == ex_expr && src_expr->e.expr.op == '=') { + if (src_expr->type == ex_assign) { sblock = statement_subexpr (sblock, src_expr, &src); if (is_structural (dst_type)) { return expr_assign_copy (sblock, e, op, src); @@ -1267,9 +1266,6 @@ expr_expr (sblock_t *sblock, expr_t *e, operand_t **op) case 'c': sblock = expr_call (sblock, e, op); break; - case '=': - sblock = expr_assign (sblock, e, op); - break; case 'm': case 'M': sblock = expr_move (sblock, e, op); @@ -1528,6 +1524,7 @@ statement_subexpr (sblock_t *sblock, expr_t *e, operand_t **op) [ex_selector] = expr_selector, [ex_alias] = expr_alias, [ex_address] = expr_address, + [ex_assign] = expr_assign, }; if (!e) { *op = 0; @@ -1574,6 +1571,10 @@ build_bool_block (expr_t *block, expr_t *e) e->next = 0; append_expr (block, e); return; + case ex_assign: + e->next = 0; + append_expr (block, e); + return; case ex_expr: if (e->e.expr.op == OR || e->e.expr.op == AND) { build_bool_block (block, e->e.expr.e1); @@ -1735,9 +1736,6 @@ statement_expr (sblock_t *sblock, expr_t *e) case IFA: sblock = statement_branch (sblock, e); break; - case '=': - sblock = expr_assign (sblock, e, 0); - break; case 'm': case 'M': sblock = expr_move (sblock, e, 0); @@ -1818,6 +1816,12 @@ statement_memset (sblock_t *sblock, expr_t *e) return sblock; } +static sblock_t * +statement_assign (sblock_t *sblock, expr_t *e) +{ + return expr_assign (sblock, e, 0); +} + static sblock_t * statement_nonexec (sblock_t *sblock, expr_t *e) { @@ -1844,6 +1848,7 @@ statement_slist (sblock_t *sblock, expr_t *e) [ex_nil] = statement_nonexec, [ex_value] = statement_nonexec, [ex_memset] = statement_memset, + [ex_assign] = statement_assign, }; for (/**/; e; e = e->next) { From 134f5ca6a48134b372563fee93e61a986fb0c99f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 8 Jan 2022 18:48:23 +0900 Subject: [PATCH 070/360] Revert "[qfcc] Fix some type aliasing bugs" This reverts commit da210db7207abc62de40bb4bb4f22c9c8ca3f4e7. Found the cause: revered to wrong case for template code --- tools/qfcc/source/expr.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index a67b1e3f1..a7c71bff3 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1387,7 +1387,7 @@ append_expr (expr_t *block, expr_t *e) static symbol_t * get_struct_field (const type_t *t1, expr_t *e1, expr_t *e2) { - symtab_t *strct = unalias_type(t1)->t.symtab; + symtab_t *strct = t1->t.symtab; symbol_t *sym = e2->e.symbol;//FIXME need to check symbol_t *field; @@ -1412,7 +1412,7 @@ field_expr (expr_t *e1, expr_t *e2) t1 = get_type (e1); if (e1->type == ex_error) return e1; - if (is_entity (t1)) { + if (t1->type == ev_entity) { symbol_t *field = 0; if (e2->type == ex_symbol) @@ -1432,8 +1432,7 @@ field_expr (expr_t *e1, expr_t *e2) return e; } } - } else if (is_pointer (t1)) { - t1 = unalias_type (t1); + } else if (t1->type == ev_pointer) { if (is_struct (t1->t.fldptr.type)) { symbol_t *field; @@ -1459,7 +1458,8 @@ field_expr (expr_t *e1, expr_t *e2) e = new_address_expr (ivar->type, e1, e2); return unary_expr ('.', e); } - } else if (is_vector (t1) || is_quaternion(t1) || is_struct (t1)) { + } else if (t1->type == ev_vector || t1->type == ev_quat + || is_struct (t1)) { symbol_t *field; field = get_struct_field (t1, e1, e2); @@ -2339,7 +2339,7 @@ array_expr (expr_t *array, expr_t *index) ind = expr_short (index); if (is_integer_val (index)) ind = expr_integer (index); - if (is_array (array_type) + if (array_type->t.func.num_params && is_constant (index) && (ind < array_type->t.array.base || ind - array_type->t.array.base >= array_type->t.array.size)) @@ -2755,7 +2755,7 @@ cast_expr (type_t *dstType, expr_t *e) dstType = (type_t *) unalias_type (dstType); //FIXME cast srcType = get_type (e); - if (dstType == unalias_type(srcType)) + if (dstType == srcType) return e; if ((dstType == type_default && is_enum (srcType)) From 62d58a2255479fc583bff918df041a510137d3f1 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 8 Jan 2022 18:48:54 +0900 Subject: [PATCH 071/360] Revert "[qfcc] Fix another type aliasing bug" This reverts commit d14f695c68c54e3683dec1de5cbb29d0005059fe. Found the cause: revered to wrong case for template code --- tools/qfcc/source/expr.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index a7c71bff3..682a9ed0e 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1945,8 +1945,7 @@ bitnot_expr: if (extract_type (e) != ev_pointer) return error (e, "invalid type for unary ."); e = new_unary_expr ('.', e); - const type_t *t = unalias_type (get_type (e->e.expr.e1)); - e->e.expr.type = t->t.fldptr.type; + e->e.expr.type = get_type (e->e.expr.e1)->t.fldptr.type; return e; case '+': if (!is_math (get_type (e))) From 14352ea65a8cd5f08cc1e8881b8c4d89a53f71f4 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 8 Jan 2022 18:49:35 +0900 Subject: [PATCH 072/360] [qfcc] Really fix those type aliasing bugs Found the cause: revered to wrong case for template code :/ --- tools/qfcc/source/expr.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 682a9ed0e..39b703f0d 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -259,9 +259,11 @@ get_type (expr_t *e) case ex_selector: return &type_SEL; case ex_alias: - return e->e.alias.type; + type = e->e.alias.type; + break; case ex_address: - return e->e.address.type; + type = e->e.address.type; + break; case ex_assign: return get_type (e->e.assign.dst); case ex_count: From 63795e790bef3b202c3c1baa3174c3c0d42821ea Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 8 Jan 2022 20:55:20 +0900 Subject: [PATCH 073/360] [qfcc] Clean out some old code The move operator names are definitely obsolete (due to dropping the expressions a year or two ago) and the precedence checks seem to be handled elsewhere. Memset and state expressions went away a while back too. --- tools/qfcc/include/expr.h | 16 ---------------- tools/qfcc/source/constfold.c | 2 +- tools/qfcc/source/dot_expr.c | 1 - tools/qfcc/source/expr.c | 27 --------------------------- tools/qfcc/source/expr_binary.c | 8 +++----- tools/qfcc/source/statements.c | 2 -- 6 files changed, 4 insertions(+), 52 deletions(-) diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 5773d834e..47d382929 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -680,22 +680,6 @@ expr_t *new_assign_expr (expr_t *dst, expr_t *src); */ expr_t *new_param_expr (struct type_s *type, int num); -/** Create an expression representing a block copy. - - This is used for structure assignments. - - \param e1 Destination of move. - \param e2 Source of move. - \param type type giving size of move. - \param indirect Move uses dereferenced pointers. - \return A new expression representing the move. -*/ -expr_t *new_move_expr (expr_t *e1, expr_t *e2, struct type_s *type, - int indirect); - -expr_t *new_memset_expr (expr_t *dst, expr_t *val, struct type_s *type); - - /** Convert a name to an expression of the appropriate type. Converts the expression in-place. If the exprssion is not a name diff --git a/tools/qfcc/source/constfold.c b/tools/qfcc/source/constfold.c index 6bc564e4a..520693b01 100644 --- a/tools/qfcc/source/constfold.c +++ b/tools/qfcc/source/constfold.c @@ -1710,7 +1710,7 @@ fold_constants (expr_t *e) } op = e->e.expr.op; - if (op == 'i' || op == 'n' || op == 'c' || op == 's') { + if (op == 'i' || op == 'n' || op == 'c') { return e; } diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index 008c99651..95c6807f1 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -97,7 +97,6 @@ get_op_string (int op) case IFA: return ""; case 'g': return ""; case 'r': return ""; - case 's': return ""; case 'c': return ""; case 'C': return ""; case 'M': return ""; diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 39b703f0d..6749422c0 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1341,33 +1341,6 @@ new_param_expr (type_t *type, int num) return param_expr (va (0, ".param_%d", num), type); } -expr_t * -new_move_expr (expr_t *e1, expr_t *e2, type_t *type, int indirect) -{ - expr_t *e = new_binary_expr (indirect ? 'M' : 'm', e1, e2); - e->e.expr.type = type; - return e; -} - -expr_t * -new_memset_expr (expr_t *dst, expr_t *val, type_t *type) -{ - expr_t *e; - if (!is_pointer (get_type (dst))) { - return error (dst, "incorrect destination type for memset"); - } - if (!is_scalar (get_type (val))) { - return error (val, "memset value must be a scalar"); - } - e = new_expr (); - e->type = ex_memset; - e->e.memset.dst = dst; - e->e.memset.val = val; - e->e.memset.count = new_integer_expr (type_size (type)); - e->e.memset.type = type; - return e; -} - expr_t * append_expr (expr_t *block, expr_t *e) { diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index eeb310c59..df304f119 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -873,7 +873,7 @@ check_precedence (int op, expr_t *e1, expr_t *e2) { if (e1->type == ex_uexpr && e1->e.expr.op == '!' && !e1->paren) { if (options.traditional) { - if (op != AND && op != OR && op != '=') { + if (op != AND && op != OR) { notice (e1, "precedence of `!' and `%s' inverted for " "traditional code", get_op_string (op)); e1->e.expr.e1->paren = 1; @@ -890,8 +890,7 @@ check_precedence (int op, expr_t *e1, expr_t *e2) if (e2->type == ex_expr && !e2->paren) { if (((op == '&' || op == '|') && (is_math_op (e2->e.expr.op) || is_compare (e2->e.expr.op))) - || (op == '=' - && (e2->e.expr.op == OR || e2->e.expr.op == AND))) { + || (e2->e.expr.op == OR || e2->e.expr.op == AND)) { notice (e1, "precedence of `%s' and `%s' inverted for " "traditional code", get_op_string (op), get_op_string (e2->e.expr.op)); @@ -912,8 +911,7 @@ check_precedence (int op, expr_t *e1, expr_t *e2) } else if (e1->type == ex_expr && !e1->paren) { if (((op == '&' || op == '|') && (is_math_op (e1->e.expr.op) || is_compare (e1->e.expr.op))) - || (op == '=' - && (e1->e.expr.op == OR || e1->e.expr.op == AND))) { + || (e1->e.expr.op == OR || e1->e.expr.op == AND)) { notice (e1, "precedence of `%s' and `%s' inverted for " "traditional code", get_op_string (op), get_op_string (e1->e.expr.op)); diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 7180dc205..a4cfe4626 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -594,8 +594,6 @@ convert_op (int op) case IFB: return ""; case IFAE: return ""; case IFA: return ""; - case 'm': return ""; - case 'M': return ""; default: return 0; } From 4111d44dcc646c306a6d70b277f27d685a8a8517 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 9 Jan 2022 00:26:52 +0900 Subject: [PATCH 074/360] [gamecode] Move progs auxiliary headers into a subdirectory Just another step along the road of tidying up the QF include directory (and desirable for generated data). --- include/QF/Makemodule.am | 11 +++++++---- include/QF/progs.h | 4 ++-- include/QF/{ => progs}/pr_comp.h | 0 include/QF/{ => progs}/pr_debug.h | 2 +- include/QF/{ => progs}/pr_obj.h | 4 ++-- include/QF/{ => progs}/pr_type.h | 2 +- include/QF/ruamoko.h | 2 +- libs/gamecode/pr_debug.c | 5 +++-- libs/gamecode/pr_v6p_opcode.c | 3 ++- libs/ruamoko/rua_obj.c | 3 ++- libs/ruamoko/rua_set.c | 3 ++- ruamoko/qwaq/debugger/debug.h | 2 +- ruamoko/qwaq/editor/editbuffer.h | 2 +- ruamoko/qwaq/ui/textcontext.h | 2 +- tools/qfcc/include/dags.h | 2 +- tools/qfcc/include/debug.h | 2 +- tools/qfcc/include/def.h | 4 ++-- tools/qfcc/include/defspace.h | 4 ++-- tools/qfcc/include/diagnostic.h | 2 -- tools/qfcc/include/expr.h | 2 +- tools/qfcc/include/function.h | 4 ++-- tools/qfcc/include/idstuff.h | 2 +- tools/qfcc/include/obj_file.h | 4 ++-- tools/qfcc/include/obj_type.h | 2 +- tools/qfcc/include/opcodes.h | 2 +- tools/qfcc/include/qfcc.h | 2 +- tools/qfcc/include/statements.h | 2 +- tools/qfcc/include/type.h | 2 +- tools/qfcc/source/class.c | 3 ++- tools/qfcc/source/codespace.c | 2 +- tools/qfcc/source/debug.c | 2 +- tools/qfcc/source/dump_lines.c | 3 ++- tools/qfcc/source/dump_modules.c | 3 ++- tools/qfcc/source/method.c | 3 ++- tools/qfcc/source/options.c | 3 ++- tools/qfcc/source/pragma.c | 3 ++- tools/qfcc/source/qfprogs.c | 3 ++- tools/qfcc/source/struct.c | 3 ++- 38 files changed, 61 insertions(+), 48 deletions(-) rename include/QF/{ => progs}/pr_comp.h (100%) rename include/QF/{ => progs}/pr_debug.h (98%) rename include/QF/{ => progs}/pr_obj.h (98%) rename include/QF/{ => progs}/pr_type.h (99%) diff --git a/include/QF/Makemodule.am b/include/QF/Makemodule.am index 77f56e29b..4f5aa35c9 100644 --- a/include/QF/Makemodule.am +++ b/include/QF/Makemodule.am @@ -43,10 +43,6 @@ include_qf = \ include/QF/plist.h \ include/QF/plugin.h \ include/QF/pqueue.h \ - include/QF/pr_comp.h \ - include/QF/pr_debug.h \ - include/QF/pr_obj.h \ - include/QF/pr_type.h \ include/QF/progs.h \ include/QF/pvsfile.h \ include/QF/qargs.h \ @@ -135,6 +131,12 @@ include_qf_plugin = \ include/QF/plugin/snd_render.h \ include/QF/plugin/vid_render.h +include_qf_progs = \ + include/QF/pr_comp.h \ + include/QF/pr_debug.h \ + include/QF/pr_obj.h \ + include/QF/pr_type.h + include_qf_scene = \ include/QF/scene/entity.h \ include/QF/scene/hierarchy.h \ @@ -232,6 +234,7 @@ EXTRA_HEADERS += \ $(include_qf_input) \ $(include_qf_math) \ $(include_qf_plugin) \ + $(include_qf_progs) \ $(include_qf_scene) \ $(include_qf_simd) \ $(include_qf_ui) \ diff --git a/include/QF/progs.h b/include/QF/progs.h index c4b2ef070..572528891 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -33,8 +33,8 @@ \image latex vm-mem.eps "VM memory map" */ -#include "QF/pr_comp.h" -#include "QF/pr_debug.h" +#include "QF/progs/pr_comp.h" +#include "QF/progs/pr_debug.h" struct QFile_s; diff --git a/include/QF/pr_comp.h b/include/QF/progs/pr_comp.h similarity index 100% rename from include/QF/pr_comp.h rename to include/QF/progs/pr_comp.h diff --git a/include/QF/pr_debug.h b/include/QF/progs/pr_debug.h similarity index 98% rename from include/QF/pr_debug.h rename to include/QF/progs/pr_debug.h index 94c164fe5..20b65c25c 100644 --- a/include/QF/pr_debug.h +++ b/include/QF/progs/pr_debug.h @@ -32,7 +32,7 @@ #define __QF_pr_debug_h #ifndef __QFCC__ -#include "QF/pr_comp.h" +#include "QF/progs/pr_comp.h" typedef struct pr_compunit_s { pr_uint_t unit_name; diff --git a/include/QF/pr_obj.h b/include/QF/progs/pr_obj.h similarity index 98% rename from include/QF/pr_obj.h rename to include/QF/progs/pr_obj.h index 52f05aa16..ea8f6a052 100644 --- a/include/QF/pr_obj.h +++ b/include/QF/progs/pr_obj.h @@ -31,7 +31,7 @@ #ifndef __QF_pr_obj_h #define __QF_pr_obj_h -#include "QF/pr_comp.h" +#include "QF/progs/pr_comp.h" #define PR_BITS_PER_INT (sizeof (pr_int_t) * 8) @@ -74,7 +74,7 @@ #define PR_CLS_GETNUMBER(cls) (__CLS_INFO (cls) >> (PR_BITS_PER_INT / 2)) #define PR_CLS_SETNUMBER(cls, num) \ (__PR_CLS_INFO (cls) = __PR_CLS_INFO (cls) & (~0U >> (PR_BITS_PER_INT / 2)) \ - | (num) << (PR_BITS_PER_INT / 2)) + | (num) << (PR_BITS_PER_INT / 2)) typedef struct pr_sel_s { pointer_t sel_id; diff --git a/include/QF/pr_type.h b/include/QF/progs/pr_type.h similarity index 99% rename from include/QF/pr_type.h rename to include/QF/progs/pr_type.h index 56915724b..04a3266f6 100644 --- a/include/QF/pr_type.h +++ b/include/QF/progs/pr_type.h @@ -38,7 +38,7 @@ */ ///@{ -#include "QF/pr_comp.h" +#include "QF/progs/pr_comp.h" typedef enum { ty_basic, ///< VM type (float, int, pointer, field, etc) diff --git a/include/QF/ruamoko.h b/include/QF/ruamoko.h index ba1531485..b6f82ff31 100644 --- a/include/QF/ruamoko.h +++ b/include/QF/ruamoko.h @@ -31,7 +31,7 @@ #ifndef __QF_ruamoko_h #define __QF_ruamoko_h -#include "QF/pr_obj.h" +#include "QF/progs/pr_obj.h" struct progs_s; struct cbuf_s; diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 98c5d0e59..b77dc940a 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -49,8 +49,6 @@ #include "QF/dstring.h" #include "QF/hash.h" #include "QF/mathlib.h" -#include "QF/pr_debug.h" -#include "QF/pr_type.h" #include "QF/progs.h" #include "QF/qendian.h" #include "QF/quakefs.h" @@ -58,6 +56,9 @@ #include "QF/sys.h" #include "QF/zone.h" +#include "QF/progs/pr_debug.h" +#include "QF/progs/pr_type.h" + #include "compat.h" typedef struct { diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index 421159648..5ded2c764 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -37,10 +37,11 @@ #endif #include "QF/cvar.h" -#include "QF/pr_comp.h" #include "QF/progs.h" #include "QF/sys.h" +#include "QF/progs/pr_comp.h" + #include "compat.h" VISIBLE const pr_ushort_t pr_type_size[ev_type_count] = { diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index 4bed1de5d..aab7b4c0f 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -48,11 +48,12 @@ #include "QF/dstring.h" #include "QF/hash.h" #include "QF/mathlib.h" -#include "QF/pr_obj.h" #include "QF/progs.h" #include "QF/ruamoko.h" #include "QF/sys.h" +#include "QF/progs/pr_obj.h" + #include "compat.h" #include "rua_internal.h" diff --git a/libs/ruamoko/rua_set.c b/libs/ruamoko/rua_set.c index 4e8b752b5..cc7ce9735 100644 --- a/libs/ruamoko/rua_set.c +++ b/libs/ruamoko/rua_set.c @@ -40,9 +40,10 @@ #include #include "QF/progs.h" -#include "QF/pr_obj.h" #include "QF/set.h" +#include "QF/progs/pr_obj.h" + #include "rua_internal.h" typedef struct { diff --git a/ruamoko/qwaq/debugger/debug.h b/ruamoko/qwaq/debugger/debug.h index 93ef60f3b..e9c1cedcf 100644 --- a/ruamoko/qwaq/debugger/debug.h +++ b/ruamoko/qwaq/debugger/debug.h @@ -9,7 +9,7 @@ typedef enum { #ifdef __QFCC__ -#include +#include //FIXME finish unsigned in qfcc #ifndef umax diff --git a/ruamoko/qwaq/editor/editbuffer.h b/ruamoko/qwaq/editor/editbuffer.h index fe8a15829..8d42c6038 100644 --- a/ruamoko/qwaq/editor/editbuffer.h +++ b/ruamoko/qwaq/editor/editbuffer.h @@ -77,7 +77,7 @@ typedef struct eb_color_s { @end #else//__QFCC__ -#include "QF/pr_obj.h" +#include "QF/progs/pr_obj.h" typedef struct qwaq_editbuffer_s { pr_id_t isa; diff --git a/ruamoko/qwaq/ui/textcontext.h b/ruamoko/qwaq/ui/textcontext.h index 21f21b5ae..d73a9895c 100644 --- a/ruamoko/qwaq/ui/textcontext.h +++ b/ruamoko/qwaq/ui/textcontext.h @@ -61,7 +61,7 @@ #else -#include "QF/pr_obj.h" +#include "QF/progs/pr_obj.h" typedef struct qwaq_textcontext_s { pr_id_t isa; diff --git a/tools/qfcc/include/dags.h b/tools/qfcc/include/dags.h index 6addafcd2..66fbece40 100644 --- a/tools/qfcc/include/dags.h +++ b/tools/qfcc/include/dags.h @@ -35,7 +35,7 @@ */ ///@{ -#include "QF/pr_comp.h" +#include "QF/progs/pr_comp.h" #include "statements.h" diff --git a/tools/qfcc/include/debug.h b/tools/qfcc/include/debug.h index af5f322b7..6e7d6f477 100644 --- a/tools/qfcc/include/debug.h +++ b/tools/qfcc/include/debug.h @@ -31,7 +31,7 @@ #ifndef __debug_h #define __debug_h -#include "QF/pr_debug.h" +#include "QF/progs/pr_debug.h" void line_info (char *text); pr_lineno_t *new_lineno (void); diff --git a/tools/qfcc/include/def.h b/tools/qfcc/include/def.h index 691c5d602..c03b221ef 100644 --- a/tools/qfcc/include/def.h +++ b/tools/qfcc/include/def.h @@ -31,8 +31,8 @@ #ifndef __def_h #define __def_h -#include "QF/pr_comp.h" -#include "QF/pr_debug.h" +#include "QF/progs/pr_comp.h" +#include "QF/progs/pr_debug.h" /** \defgroup qfcc_def Def handling \ingroup qfcc diff --git a/tools/qfcc/include/defspace.h b/tools/qfcc/include/defspace.h index e0414f1c9..6e839ce67 100644 --- a/tools/qfcc/include/defspace.h +++ b/tools/qfcc/include/defspace.h @@ -31,8 +31,8 @@ #ifndef __defspace_h #define __defspace_h -#include "QF/pr_comp.h" -#include "QF/pr_debug.h" +#include "QF/progs/pr_comp.h" +#include "QF/progs/pr_debug.h" /** \defgroup qfcc_defspace Defspace handling \ingroup qfcc diff --git a/tools/qfcc/include/diagnostic.h b/tools/qfcc/include/diagnostic.h index 958b44d66..8adec809c 100644 --- a/tools/qfcc/include/diagnostic.h +++ b/tools/qfcc/include/diagnostic.h @@ -31,8 +31,6 @@ #ifndef __diagnostic_h #define __diagnostic_h -#include "QF/pr_comp.h" - /** \defgroup qfcc_diagnostic Diagnostic Messages \ingroup qfcc */ diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 47d382929..6293a8103 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -31,7 +31,7 @@ #ifndef __expr_h #define __expr_h -#include "QF/pr_comp.h" +#include "QF/progs/pr_comp.h" /** \defgroup qfcc_expr Expressions \ingroup qfcc diff --git a/tools/qfcc/include/function.h b/tools/qfcc/include/function.h index 48a82f9e9..986f513eb 100644 --- a/tools/qfcc/include/function.h +++ b/tools/qfcc/include/function.h @@ -36,8 +36,8 @@ */ ///@{ -#include "QF/pr_comp.h" -#include "QF/pr_debug.h" +#include "QF/progs/pr_comp.h" +#include "QF/progs/pr_debug.h" #include "def.h" diff --git a/tools/qfcc/include/idstuff.h b/tools/qfcc/include/idstuff.h index 82ef617f8..2eadb691b 100644 --- a/tools/qfcc/include/idstuff.h +++ b/tools/qfcc/include/idstuff.h @@ -31,7 +31,7 @@ #ifndef __idstuff_h #define __idstuff_h -#include "QF/pr_comp.h" +#include "QF/progs/pr_comp.h" //XXX eww :/ void PrecacheSound (const char *, int ch); diff --git a/tools/qfcc/include/obj_file.h b/tools/qfcc/include/obj_file.h index f49688f0f..8d6c40a22 100644 --- a/tools/qfcc/include/obj_file.h +++ b/tools/qfcc/include/obj_file.h @@ -36,8 +36,8 @@ */ ///@{ -#include "QF/pr_comp.h" -#include "QF/pr_debug.h" +#include "QF/progs/pr_comp.h" +#include "QF/progs/pr_debug.h" #include "QF/quakeio.h" /** Identifier string for qfo object files (includes terminating nul) diff --git a/tools/qfcc/include/obj_type.h b/tools/qfcc/include/obj_type.h index a8c546703..c3d9cb6e7 100644 --- a/tools/qfcc/include/obj_type.h +++ b/tools/qfcc/include/obj_type.h @@ -31,7 +31,7 @@ #ifndef __obj_type_h #define __obj_type_h -#include "QF/pr_type.h" +#include "QF/progs/pr_type.h" #include "type.h" diff --git a/tools/qfcc/include/opcodes.h b/tools/qfcc/include/opcodes.h index 2966235e6..fa100fb6b 100644 --- a/tools/qfcc/include/opcodes.h +++ b/tools/qfcc/include/opcodes.h @@ -31,7 +31,7 @@ #ifndef __opcodes_h #define __opcodes_h -#include "QF/pr_comp.h" +#include "QF/progs/pr_comp.h" typedef struct instruction_s instruction_t; diff --git a/tools/qfcc/include/qfcc.h b/tools/qfcc/include/qfcc.h index 9d552ab3e..4ac5e0ddb 100644 --- a/tools/qfcc/include/qfcc.h +++ b/tools/qfcc/include/qfcc.h @@ -35,7 +35,7 @@ #include #include "QF/darray.h" -#include "QF/pr_comp.h" +#include "QF/progs/pr_comp.h" /** \defgroup qfcc_general General functions \ingroup qfcc diff --git a/tools/qfcc/include/statements.h b/tools/qfcc/include/statements.h index bc15244c6..386dad198 100644 --- a/tools/qfcc/include/statements.h +++ b/tools/qfcc/include/statements.h @@ -30,7 +30,7 @@ #ifndef statement_h #define statement_h -#include "QF/pr_comp.h" +#include "QF/progs/pr_comp.h" typedef enum { op_def, diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h index ca079eb01..f985ea826 100644 --- a/tools/qfcc/include/type.h +++ b/tools/qfcc/include/type.h @@ -31,7 +31,7 @@ #ifndef __type_h #define __type_h -#include "QF/pr_type.h" +#include "QF/progs/pr_type.h" #include "def.h" diff --git a/tools/qfcc/source/class.c b/tools/qfcc/source/class.c index dfaf638c8..7858f82fa 100644 --- a/tools/qfcc/source/class.c +++ b/tools/qfcc/source/class.c @@ -41,9 +41,10 @@ #include "QF/dstring.h" #include "QF/hash.h" -#include "QF/pr_obj.h" #include "QF/va.h" +#include "QF/progs/pr_obj.h" + #include "tools/qfcc/include/qfcc.h" #include "tools/qfcc/include/codespace.h" diff --git a/tools/qfcc/source/codespace.c b/tools/qfcc/source/codespace.c index b7cd56bcc..5d6aee439 100644 --- a/tools/qfcc/source/codespace.c +++ b/tools/qfcc/source/codespace.c @@ -39,7 +39,7 @@ #endif #include -#include "QF/pr_comp.h" +#include "QF/progs/pr_comp.h" #include "tools/qfcc/include/codespace.h" diff --git a/tools/qfcc/source/debug.c b/tools/qfcc/source/debug.c index ec0367fa0..644ee31d9 100644 --- a/tools/qfcc/source/debug.c +++ b/tools/qfcc/source/debug.c @@ -41,7 +41,7 @@ #include #include "QF/alloc.h" -#include "QF/pr_comp.h" +#include "QF/progs/pr_comp.h" #include "tools/qfcc/include/debug.h" #include "tools/qfcc/include/def.h" diff --git a/tools/qfcc/source/dump_lines.c b/tools/qfcc/source/dump_lines.c index bfaffdc6e..7ff66fabb 100644 --- a/tools/qfcc/source/dump_lines.c +++ b/tools/qfcc/source/dump_lines.c @@ -41,7 +41,8 @@ #include #include "QF/progs.h" -#include "QF/pr_type.h" + +#include "QF/progs/pr_type.h" #include "tools/qfcc/include/obj_file.h" #include "tools/qfcc/include/qfprogs.h" diff --git a/tools/qfcc/source/dump_modules.c b/tools/qfcc/source/dump_modules.c index 0fcda6e50..3897610b7 100644 --- a/tools/qfcc/source/dump_modules.c +++ b/tools/qfcc/source/dump_modules.c @@ -40,10 +40,11 @@ #include -#include "QF/pr_obj.h" #include "QF/progs.h" #include "QF/va.h" +#include "QF/progs/pr_obj.h" + #include "tools/qfcc/include/qfprogs.h" static void diff --git a/tools/qfcc/source/method.c b/tools/qfcc/source/method.c index 134f1cc64..9c82f89d5 100644 --- a/tools/qfcc/source/method.c +++ b/tools/qfcc/source/method.c @@ -41,9 +41,10 @@ #include "QF/dstring.h" #include "QF/hash.h" -#include "QF/pr_obj.h" #include "QF/va.h" +#include "QF/progs/pr_obj.h" + #include "tools/qfcc/include/qfcc.h" #include "tools/qfcc/include/expr.h" diff --git a/tools/qfcc/source/options.c b/tools/qfcc/source/options.c index 2e701c403..7283ba9f7 100644 --- a/tools/qfcc/source/options.c +++ b/tools/qfcc/source/options.c @@ -42,9 +42,10 @@ #include -#include "QF/pr_comp.h" #include "QF/va.h" +#include "QF/progs/pr_comp.h" + #include "tools/qfcc/include/cpp.h" #include "tools/qfcc/include/linker.h" #include "tools/qfcc/include/options.h" diff --git a/tools/qfcc/source/pragma.c b/tools/qfcc/source/pragma.c index edabcaaf4..60448815e 100644 --- a/tools/qfcc/source/pragma.c +++ b/tools/qfcc/source/pragma.c @@ -40,7 +40,8 @@ #include #include "QF/alloc.h" -#include "QF/pr_comp.h" + +#include "QF/progs/pr_comp.h" #include "tools/qfcc/include/diagnostic.h" #include "tools/qfcc/include/opcodes.h" diff --git a/tools/qfcc/source/qfprogs.c b/tools/qfcc/source/qfprogs.c index eea6aa7e8..19c7ed873 100644 --- a/tools/qfcc/source/qfprogs.c +++ b/tools/qfcc/source/qfprogs.c @@ -56,13 +56,14 @@ #include "QF/cvar.h" #include "QF/hash.h" #include "QF/mathlib.h" -#include "QF/pr_comp.h" #include "QF/progs.h" #include "QF/quakeio.h" #include "QF/sys.h" #include "QF/va.h" #include "QF/zone.h" +#include "QF/progs/pr_comp.h" + #include "tools/qfcc/include/obj_file.h" #include "tools/qfcc/include/obj_type.h" #include "tools/qfcc/include/qfprogs.h" diff --git a/tools/qfcc/source/struct.c b/tools/qfcc/source/struct.c index 4bd82130c..164a491a2 100644 --- a/tools/qfcc/source/struct.c +++ b/tools/qfcc/source/struct.c @@ -43,10 +43,11 @@ #include #include -#include #include #include +#include + #include "tools/qfcc/include/class.h" #include "tools/qfcc/include/def.h" #include "tools/qfcc/include/defspace.h" From 7d5c692313a70bfd6aa2f51d9ed6069def2d4ee2 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 9 Jan 2022 01:04:51 +0900 Subject: [PATCH 075/360] [gamecode] Generate the new opcodes enum too It turns out I'll be tweaking it more than I expected. --- include/QF/progs/pr_comp.h | 170 +----------------------------------- libs/gamecode/Makemodule.am | 13 ++- libs/gamecode/opcodes.py | 55 +++++++++--- 3 files changed, 54 insertions(+), 184 deletions(-) diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 9e819ad38..9b30bf170 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -427,175 +427,9 @@ typedef enum { #define OP_BREAK 0x8000 typedef enum { - // 0 0000 load from [a,b] -> c - OP_LOAD_E_1, OP_LOAD_E_2, OP_LOAD_E_3, OP_LOAD_E_4, - OP_LOAD_B_1, OP_LOAD_B_2, OP_LOAD_B_3, OP_LOAD_B_4, - OP_LOAD_C_1, OP_LOAD_C_2, OP_LOAD_C_3, OP_LOAD_C_4, - OP_LOAD_D_1, OP_LOAD_D_2, OP_LOAD_D_3, OP_LOAD_D_4, - // 0 0001 store from c -> [a, b] - OP_STORE_A_1, OP_STORE_A_2, OP_STORE_A_3, OP_STORE_A_4, // redundant? - OP_STORE_B_1, OP_STORE_B_2, OP_STORE_B_3, OP_STORE_B_4, - OP_STORE_C_1, OP_STORE_C_2, OP_STORE_C_3, OP_STORE_C_4, - OP_STORE_D_1, OP_STORE_D_2, OP_STORE_D_3, OP_STORE_D_4, - // 0 0010 push from [a,b] to the stack - OP_PUSH_A_1, OP_PUSH_A_2, OP_PUSH_A_3, OP_PUSH_A_4, - OP_PUSH_B_1, OP_PUSH_B_2, OP_PUSH_B_3, OP_PUSH_B_4, - OP_PUSH_C_1, OP_PUSH_C_2, OP_PUSH_C_3, OP_PUSH_C_4, - OP_PUSH_D_1, OP_PUSH_D_2, OP_PUSH_D_3, OP_PUSH_D_4, - // 0 0011 pop from the stack to [a,b] - OP_POP_A_1, OP_POP_A_2, OP_POP_A_3, OP_POP_A_4, - OP_POP_B_1, OP_POP_B_2, OP_POP_B_3, OP_POP_B_4, - OP_POP_C_1, OP_POP_C_2, OP_POP_C_3, OP_POP_C_4, - OP_POP_D_1, OP_POP_D_2, OP_POP_D_3, OP_POP_D_4, - // 0 0100 flow control - OP_IFNOT_A, OP_IFNOT_B, OP_IFNOT_C, OP_IFNOT_D, - OP_IF_A, OP_IF_B, OP_IF_C, OP_IF_D, - OP_JUMP_A, OP_JUMP_B, OP_JUMP_C, OP_JUMP_D, - OP_CALL_A, OP_CALL_B, OP_CALL_C, OP_CALL_D, - // 0 0101 calls - OP_CALL_1, OP_CALL_2, OP_CALL_3, OP_CALL_4, - OP_CALL_5, OP_CALL_6, OP_CALL_7, OP_CALL_8, - OP_RETURN_1, OP_RETURN_2, OP_RETURN_3, OP_RETURN_4, - OP_RETURN_0, OP_WITH, OP_STATE_ft, OP_STATE_ftt, - // 0 0110 flow control 2 - OP_IFA_A, OP_IFA_B, OP_IFA_C, OP_IFA_D, - OP_IFBE_A, OP_IFBE_B, OP_IFBE_C, OP_IFBE_D, - OP_IFB_A, OP_IFB_B, OP_IFB_C, OP_IFB_D, - OP_IFAE_A, OP_IFAE_B, OP_IFAE_C, OP_IFAE_D, - // 0 0111 interpreted vector multiplication - // C complex - // V vector (3d) - // Q quaternion - OP_CDOT_F, OP_VDOT_F, OP_QDOT_F, OP_CROSS_F, - OP_CMUL_F, OP_QVMUL_F, OP_VQMUL_F, OP_QMUL_F, - OP_CDOT_D, OP_VDOT_D, OP_QDOT_D, OP_CROSS_D, - OP_CMUL_D, OP_QVMUL_D, OP_VQMUL_D, OP_QMUL_D, - // comparison - // 0 1000 == - OP_EQ_I_1, OP_EQ_I_2, OP_EQ_I_3, OP_EQ_I_4, - OP_EQ_F_1, OP_EQ_F_2, OP_EQ_F_3, OP_EQ_F_4, - OP_EQ_L_1, OP_EQ_L_2, OP_EQ_L_3, OP_EQ_L_4, - OP_EQ_D_1, OP_EQ_D_2, OP_EQ_D_3, OP_EQ_D_4, - // 0 1001 < - OP_LT_I_1, OP_LT_I_2, OP_LT_I_3, OP_LT_I_4, - OP_LT_F_1, OP_LT_F_2, OP_LT_F_3, OP_LT_F_4, - OP_LT_L_1, OP_LT_L_2, OP_LT_L_3, OP_LT_L_4, - OP_LT_D_1, OP_LT_D_2, OP_LT_D_3, OP_LT_D_4, - // 0 1010 > - OP_GT_I_1, OP_GT_I_2, OP_GT_I_3, OP_GT_I_4, - OP_GT_F_1, OP_GT_F_2, OP_GT_F_3, OP_GT_F_4, - OP_GT_L_1, OP_GT_L_2, OP_GT_L_3, OP_GT_L_4, - OP_GT_D_1, OP_GT_D_2, OP_GT_D_3, OP_GT_D_4, - // 0 1011 - OP_spare_1, OP_spare_2, OP_spare_3, OP_spare_4, - OP_spare_5, OP_spare_6, OP_spare_7, OP_spare_8, - OP_spare_9, OP_spare_10, OP_spare_11, OP_spare_12, - OP_spare_13, OP_spare_14, OP_spare_15, OP_spare_16, - // comparison - // 0 1100 != - OP_NE_I_1, OP_NE_I_2, OP_NE_I_3, OP_NE_I_4, - OP_NE_F_1, OP_NE_F_2, OP_NE_F_3, OP_NE_F_4, - OP_NE_L_1, OP_NE_L_2, OP_NE_L_3, OP_NE_L_4, - OP_NE_D_1, OP_NE_D_2, OP_NE_D_3, OP_NE_D_4, - // 0 1101 >= - OP_GE_I_1, OP_GE_I_2, OP_GE_I_3, OP_GE_I_4, - OP_GE_F_1, OP_GE_F_2, OP_GE_F_3, OP_GE_F_4, - OP_GE_L_1, OP_GE_L_2, OP_GE_L_3, OP_GE_L_4, - OP_GE_D_1, OP_GE_D_2, OP_GE_D_3, OP_GE_D_4, - // 0 1110 <= - OP_LE_I_1, OP_LE_I_2, OP_LE_I_3, OP_LE_I_4, - OP_LE_F_1, OP_LE_F_2, OP_LE_F_3, OP_LE_F_4, - OP_LE_L_1, OP_LE_L_2, OP_LE_L_3, OP_LE_L_4, - OP_LE_D_1, OP_LE_D_2, OP_LE_D_3, OP_LE_D_4, - // 0 1111 - OP_spare_17, OP_spare_18, OP_spare_19, OP_spare_20, - OP_spare_21, OP_spare_22, OP_spare_23, OP_spare_24, - OP_spare_25, OP_spare_26, OP_spare_27, OP_spare_28, - OP_spare_29, OP_spare_30, OP_spare_31, OP_spare_32, - - // 1 0000 c = a * b - OP_MUL_I_1, OP_MUL_I_2, OP_MUL_I_3, OP_MUL_I_4, - OP_MUL_F_1, OP_MUL_F_2, OP_MUL_F_3, OP_MUL_F_4, - OP_MUL_L_1, OP_MUL_L_2, OP_MUL_L_3, OP_MUL_L_4, - OP_MUL_D_1, OP_MUL_D_2, OP_MUL_D_3, OP_MUL_D_4, - // 1 0001 c = a / b - OP_DIV_I_1, OP_DIV_I_2, OP_DIV_I_3, OP_DIV_I_4, - OP_DIV_F_1, OP_DIV_F_2, OP_DIV_F_3, OP_DIV_F_4, - OP_DIV_L_1, OP_DIV_L_2, OP_DIV_L_3, OP_DIV_L_4, - OP_DIV_D_1, OP_DIV_D_2, OP_DIV_D_3, OP_DIV_D_4, - // 1 0010 c = a % b (remainder, C %) - OP_REM_I_1, OP_REM_I_2, OP_REM_I_3, OP_REM_I_4, - OP_REM_F_1, OP_REM_F_2, OP_REM_F_3, OP_REM_F_4, - OP_REM_L_1, OP_REM_L_2, OP_REM_L_3, OP_REM_L_4, - OP_REM_D_1, OP_REM_D_2, OP_REM_D_3, OP_REM_D_4, - // 1 0011 c = a %% b (true modulo, python %) - OP_MOD_I_1, OP_MOD_I_2, OP_MOD_I_3, OP_MOD_I_4, - OP_MOD_F_1, OP_MOD_F_2, OP_MOD_F_3, OP_MOD_F_4, - OP_MOD_L_1, OP_MOD_L_2, OP_MOD_L_3, OP_MOD_L_4, - OP_MOD_D_1, OP_MOD_D_2, OP_MOD_D_3, OP_MOD_D_4, - // 1 0100 c = a + b - OP_ADD_I_1, OP_ADD_I_2, OP_ADD_I_3, OP_ADD_I_4, - OP_ADD_F_1, OP_ADD_F_2, OP_ADD_F_3, OP_ADD_F_4, - OP_ADD_L_1, OP_ADD_L_2, OP_ADD_L_3, OP_ADD_L_4, - OP_ADD_D_1, OP_ADD_D_2, OP_ADD_D_3, OP_ADD_D_4, - // 1 0101 c = a - b - OP_SUB_I_1, OP_SUB_I_2, OP_SUB_I_3, OP_SUB_I_4, - OP_SUB_F_1, OP_SUB_F_2, OP_SUB_F_3, OP_SUB_F_4, - OP_SUB_L_1, OP_SUB_L_2, OP_SUB_L_3, OP_SUB_L_4, - OP_SUB_D_1, OP_SUB_D_2, OP_SUB_D_3, OP_SUB_D_4, - // 1 0110 c = a << b (string ops mixed in) - OP_SHL_I_1, OP_SHL_I_2, OP_SHL_I_3, OP_SHL_I_4, - OP_EQ_S, OP_LT_S, OP_GT_S, OP_ADD_S, - OP_SHL_L_1, OP_SHL_L_2, OP_SHL_L_3, OP_SHL_L_4, - OP_CMP_S, OP_GE_S, OP_LE_S, OP_NOT_S, //OP_CMP_S doubles as NE - // 1 0111 c = a >> b - OP_ASR_I_1, OP_ASR_I_2, OP_ASR_I_3, OP_ASR_I_4, - OP_SHR_u_1, OP_SHR_u_2, OP_SHR_u_3, OP_SHR_u_4, - OP_ASR_L_1, OP_ASR_L_2, OP_ASR_L_3, OP_ASR_L_4, - OP_SHR_U_1, OP_SHR_U_2, OP_SHR_U_3, OP_SHR_U_4, - // 1 1000 c = a (& | ^) b or ~a (bitwise ops) - OP_BITAND_I_1, OP_BITAND_I_2, OP_BITAND_I_3, OP_BITAND_I_4, - OP_BITOR_I_1, OP_BITOR_I_2, OP_BITOR_I_3, OP_BITOR_I_4, - OP_BITXOR_I_1, OP_BITXOR_I_2, OP_BITXOR_I_3, OP_BITXOR_I_4, - OP_BITNOT_I_1, OP_BITNOT_I_2, OP_BITNOT_I_3, OP_BITNOT_I_4, - // 1 1001 < unsigned with swizzle and scale mixed in - OP_LT_u_1, OP_LT_u_2, OP_LT_u_3, OP_LT_u_4, - OP_SWIZZLE_F, OP_SCALE_F_2, OP_SCALE_F_3, OP_SCALE_F_4, - OP_LT_U_1, OP_LT_U_2, OP_LT_U_3, OP_LT_U_4, - OP_SWIZZLE_D, OP_SCALE_D_2, OP_SCALE_D_3, OP_SCALE_D_4, - // 1 1010 > unsigned and conversions - OP_GT_u_1, OP_GT_u_2, OP_GT_u_3, OP_GT_u_4, - OP_CONV_IF, OP_CONV_LD, OP_CONV_uF, OP_CONV_UD, - OP_GT_U_1, OP_GT_U_2, OP_GT_U_3, OP_GT_U_4, - OP_CONV_FI, OP_CONV_DL, OP_CONV_Fu, OP_CONV_DU, - // 1 1011 lea, with, etc - OP_LEA_A, OP_LEA_B, OP_LEA_C, OP_LEA_D, - OP_LEA_E, OP_ANY_2, OP_ANY_3, OP_ANY_4, - OP_PUSHREGS, OP_ALL_2, OP_ALL_3, OP_ALL_4, - OP_POPREGS, OP_NONE_2, OP_NONE_3, OP_NONE_4, - // 1 1100 c = a (&& || ^^) b or !a (logical ops (no short circuit)) - OP_AND_I_1, OP_AND_I_2, OP_AND_I_3, OP_AND_I_4, - OP_OR_I_1, OP_OR_I_2, OP_OR_I_3, OP_OR_I_4, - OP_XOR_I_1, OP_XOR_I_2, OP_XOR_I_3, OP_XOR_I_4, - OP_NOT_I_1, OP_NOT_I_2, OP_NOT_I_3, OP_NOT_I_4, - // 1 1101 >= unsigned with q v4 mul and moves mixed in - OP_GE_u_1, OP_GE_u_2, OP_GE_u_3, OP_GE_u_4, - OP_QV4MUL_F, OP_MOVE_I, OP_MOVE_P, OP_MOVE_PI, - OP_GE_U_1, OP_GE_U_2, OP_GE_U_3, OP_GE_U_4, - OP_QV4MUL_D, OP_MEMSET_I, OP_MEMSET_P, OP_MEMSET_PI, - // 1 1110 <= unsigned with v4 q mul and conversion mixed in - OP_LE_u_1, OP_LE_u_2, OP_LE_u_3, OP_LE_u_4, - OP_V4QMUL_F, OP_CONV_IL_1, OP_CONV_uU_1, OP_CONV_FD_1, - OP_LE_U_1, OP_LE_U_2, OP_LE_U_3, OP_LE_U_4, - OP_V4QMUL_D, OP_CONV_LI_1, OP_CONV_Uu_1, OP_CONV_DF_1, - // 1 1111 - OP_spare_33, OP_spare_34, OP_spare_35, OP_spare_36, - OP_spare_37, OP_spare_38, OP_spare_39, OP_spare_40, - OP_spare_41, OP_spare_42, OP_spare_43, OP_spare_44, - OP_spare_45, OP_spare_46, OP_spare_47, OP_spare_48, - - +#include "QF/progs/pr_opcode.hinc" } pr_opcode_e; + #define OP_A_SHIFT (9) #define OP_B_SHIFT (11) #define OP_C_SHIFT (13) diff --git a/libs/gamecode/Makemodule.am b/libs/gamecode/Makemodule.am index 620edc7ee..e3c9b5441 100644 --- a/libs/gamecode/Makemodule.am +++ b/libs/gamecode/Makemodule.am @@ -25,10 +25,19 @@ noinst_PYTHON += $(opcodes_py) opcodes_py = $(srcdir)/libs/gamecode/opcodes.py pr_opcode_cinc = $(top_builddir)/libs/gamecode/pr_opcode.cinc +pr_opcode_hinc = $(top_builddir)/include/QF/progs/pr_opcode.hinc pr_opcode_src = \ - ${pr_opcode_cinc} + ${pr_opcode_cinc} \ + ${pr_opcode_hinc} libs/gamecode/pr_opcode.lo: libs/gamecode/pr_opcode.c ${pr_opcode_src} +BUILT_SOURCES += $(pr_opcode_cinc) $(pr_opcode_hinc) + $(pr_opcode_cinc): $(opcodes_py) - $(V_PY)$(PYTHON) $(opcodes_py) > $(pr_opcode_cinc).t && \ + $(V_PY)$(PYTHON) $(opcodes_py) table > $(pr_opcode_cinc).t && \ $(am__mv) $(pr_opcode_cinc).t $(pr_opcode_cinc) + +$(pr_opcode_hinc): $(opcodes_py) + $(V_PY) mkdir -p `dirname $(pr_opcode_hinc)` &&\ + $(PYTHON) $(opcodes_py) enum > $(pr_opcode_hinc).t && \ + $(am__mv) $(pr_opcode_hinc).t $(pr_opcode_hinc) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index b38763156..0c18dafe6 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -36,6 +36,8 @@ n 1111 nnnn 0 1011 nnnn """ +import copy + load_fmt = [ "%Ga.%Gb(%Ea), %gc", "*%Ga, %gc", @@ -184,6 +186,15 @@ convert_formats = { ], }, } +convert2_formats = copy.deepcopy (convert_formats) +convert2_formats["args"]["op_conv"] = [None, "IL", "uU", "FD", + None, "LI", "Uu", "DF"] +convert2_formats["args"]["cnv_types"] = [ + [None, None], + ["ev_integer", "ev_long"], + ["ev_uinteger", "ev_ulong"], + ["ev_float", "ev_double"], +] lea_formats = { "opcode": "OP_LEA_{op_mode[mm]}", "mnemonic": "lea", @@ -505,7 +516,7 @@ group_map = { "compare": compare_formats, "compare2": compare2_formats, "convert": convert_formats, - "convert2": convert_formats, + "convert2": convert2_formats, "lea": lea_formats, "lea_e": lea_e_formats, "load": load_formats, @@ -598,6 +609,12 @@ def process_opcode(opcode, group): inst["wd"] = "{%s}" % eval(f'''f"{gm['widths']}"''', params) inst["ty"] = "{%s}" % eval(f'''f"{gm['types']}"''', params) +import sys + +if len (sys.argv) < 2 or sys.argv[1] not in ["enum", "table"]: + sys.stderr.write ("specify output type: enum or table\n") + sys.exit(1) + lines = bitmap_txt.split('\n') for l in lines: if not l: @@ -612,16 +629,26 @@ for l in lines: for i, group in enumerate(opcodes): if group is not None: process_opcode (i, group) -N = 8 -W = 9 -#for i in range(len(opcodes)//N): -# print("%03x" % (i << 3), " ".join(map(lambda op: "%-*.*s" % (W, W, op and op["op"] or None), opcodes[i*N:i*N+N]))) -for i, group in enumerate(opcodes): - if group is not None: - print(eval('f"[{op}] = {{\\n' - '\\t.opname = {on},\\n' - '\\t.mnemonic = {mn},\\n' - '\\t.widths = {wd},\\n' - '\\t.types = {ty},\\n' - '\\t.fmt = {fmt},\\n' - '}},"', group)) +if sys.argv[1] == "enum": + N = 4 + W = 15 + for i in range(len(opcodes)//N): + row = opcodes[i * N:i * N + N] + #row = map(lambda op: (op and op["op"] or f"OP_spare_{i}"), row) + row = [(op and op["op"] or f"OP_spare_{i*N+x}") + for x, op in enumerate(row)] + row = map(lambda op: f"%-{W}.{W}s" % (op + ','), row) + if sys.argv[2:3] == ["debug"]: + print("%03x" % (i << 3), " ".join(row)) + else: + print(" ".join(row)) +elif sys.argv[1] == "table": + for i, group in enumerate(opcodes): + if group is not None: + print(eval('f"[{op}] = {{\\n' + '\\t.opname = {on},\\n' + '\\t.mnemonic = {mn},\\n' + '\\t.widths = {wd},\\n' + '\\t.types = {ty},\\n' + '\\t.fmt = {fmt},\\n' + '}},"', group)) From 86e81ba250ead6666085bb0b6e88f4d8ff2838d8 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 9 Jan 2022 01:07:23 +0900 Subject: [PATCH 076/360] [gamecode] Rearrange the branch instructions Now they're in a much more consistent arrangement, in particular with the comparison opcodes if the conditional branch instructions are considered to be fast comparisons with zero (ifnot -> ifeq, if -> ifne, etc). Unconditional jump and call fill in the gaps. The goal was to get them all in an arrangement that would work as a small enum for qfcc: it can use the enum directly for the ruamoko IS, and a small map array for v6p (except for call). --- libs/gamecode/opcodes.py | 52 ++++++++++++++-------------------------- 1 file changed, 18 insertions(+), 34 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 0c18dafe6..9d71b94e5 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -3,13 +3,12 @@ bitmap_txt = """ 0 0001 mmss store 0 0010 mmss push 0 0011 mmss pop -0 0100 ccmm branch -0 0101 0nnn rcall 1-8 (0 0100 11mm with 0 params for [r]call0) -0 0101 10ss return -0 0101 1100 returnv -0 0101 1101 with (reg encoded in st->c) -0 0101 111t state -0 0110 ccmm branch2 +0 010c ccmm branch +0 0110 0nnn rcall 1-8 (0 0100 11mm with 0 params for [r]call0) +0 0110 10ss return +0 0110 1100 returnv +0 0110 1101 with (reg encoded in st->c) +0 0110 111t state 0 0111 tooo vecops 0 1ccc ttss compare 1 0ooo ttss mathops @@ -107,41 +106,27 @@ boolops_formats = { }, } branch_formats = { - "opcode": "OP_{op_cond[cc].upper()}_{op_mode[mm]}", - "mnemonic": "{op_cond[cc]}", - "opname": "{op_cond[cc]}", - "format": "{cond_fmt[cc]}{branch_fmt[mm]}", - "widths": "{cond_widths[cc]}", + "opcode": "OP_{op_cond[ccc].upper()}_{op_mode[mm]}", + "mnemonic": "{op_cond[ccc]}", + "opname": "{op_cond[ccc]}", + "format": "{cond_fmt[ccc]}{branch_fmt[mm]}", + "widths": "{cond_widths[ccc]}", "types": "ev_void, ev_void, ev_integer", "args": { "op_mode": "ABCD", - "op_cond": ["ifnot", "if", "jump", "call"], - "branch_fmt": branch_fmt, - "cond_fmt": ["%Gc ", "%Gc ", "", ""], - "cond_widths": [ - "0, 0, 1", - "0, 0, 1", - "0, 0, 0", - "0, 0, 0", - ], - }, -} -branch2_formats = { - "opcode": "OP_{op_cond[cc].upper()}_{op_mode[mm]}", - "mnemonic": "{op_cond[cc]}", - "opname": "{op_cond[cc]}", - "format": "%Gc {branch_fmt[mm]}", - "widths": "{cond_widths[cc]}", - "types": "ev_void, ev_void, ev_integer", - "args": { - "op_mode": "ABCD", - "op_cond": ["ifa", "ifbe", "ifb", "ifae"], + "op_cond": ["ifnot", "ifb", "ifa", "jump", + "if", "ifae", "ifbe", "call"], "branch_fmt": branch_fmt, + "cond_fmt": ["%Gc ", "%Gc ", "%Gc ", "", "%Gc ", "%Gc ", "%Gc ", ""], "cond_widths": [ "0, 0, 1", "0, 0, 1", "0, 0, 1", + "0, 0, 0", "0, 0, 1", + "0, 0, 1", + "0, 0, 1", + "0, 0, 0", ], }, } @@ -512,7 +497,6 @@ group_map = { "bitops": bitops_formats, "boolops": boolops_formats, "branch": branch_formats, - "branch2": branch2_formats, "compare": compare_formats, "compare2": compare2_formats, "convert": convert_formats, From 09002c17e65f739115fdfc40179a09c20d26b119 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 9 Jan 2022 13:56:09 +0900 Subject: [PATCH 077/360] [gamecode] Add an enum for the different branch types While it doesn't cover the addressing modes, it does match the bit pattern used in the Ruamoko instruction set. It will make selecting branch instructions easier (especially for Ruamoko). --- include/QF/progs/pr_comp.h | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 9b30bf170..8ce204613 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -430,6 +430,20 @@ typedef enum { #include "QF/progs/pr_opcode.hinc" } pr_opcode_e; +// Used for both branch and comparison, with jump and call being ignored for +// comparison. For branches, the test is against zero, while for comparison, +// it's a cmp b (where cmp takes the place of "branch" in the enum names). +typedef enum { + pr_branch_eq, + pr_branch_lt, + pr_branch_gt, + pr_branch_jump, + pr_branch_ne, + pr_branch_ge, + pr_branch_le, + pr_branch_call, +} pr_branch_e; + #define OP_A_SHIFT (9) #define OP_B_SHIFT (11) #define OP_C_SHIFT (13) From 563de2020879bee717316350e41317571fe08e59 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 9 Jan 2022 14:02:16 +0900 Subject: [PATCH 078/360] [qfcc] Give branch expressions their own type This includes calls and unconditional jumps, relative and through a table. The parameters are all lumped into the one object, with some being unused by the different types (eg, args and ret_type used only by call expressions). Just having nice names for the parameters (instead of e1 and e2) makes it nice, even with all the sub-types lumped together. No mysterious type aliasing bugs this time ;) --- tools/qfcc/include/expr.h | 12 +++ tools/qfcc/include/expr_names.h | 3 +- tools/qfcc/source/constfold.c | 25 +----- tools/qfcc/source/dot_expr.c | 153 +++++++++++++++++++------------- tools/qfcc/source/expr.c | 94 +++++++++++++++++--- tools/qfcc/source/expr_assign.c | 1 + tools/qfcc/source/expr_bool.c | 11 +-- tools/qfcc/source/qc-parse.y | 4 +- tools/qfcc/source/qp-parse.y | 2 +- tools/qfcc/source/statements.c | 144 +++++++++++++----------------- tools/qfcc/source/switch.c | 12 +-- 11 files changed, 263 insertions(+), 198 deletions(-) diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 6293a8103..ff8c25cf7 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -224,6 +224,15 @@ typedef struct { struct expr_s *src; ///< source of assignment } ex_assign_t; +typedef struct { + pr_branch_e type; ///< type of branch + struct expr_s *target; ///< destination of branch + struct expr_s *index; ///< index for indirect branches + struct expr_s *test; ///< test expression (null for jump/call) + struct expr_s *args; ///< only for call + struct type_s *ret_type; ///< void for non-call +} ex_branch_t; + #define POINTER_VAL(p) (((p).def ? (p).def->offset : 0) + (p).val) typedef struct expr_s { @@ -253,6 +262,7 @@ typedef struct expr_s { ex_alias_t alias; ///< alias expr params ex_address_t address; ///< alias expr params ex_assign_t assign; ///< assignment expr params + ex_branch_t branch; ///< branch expr params struct type_s *nil; ///< type for nil if known } e; } expr_t; @@ -718,6 +728,8 @@ expr_t *function_expr (expr_t *e1, expr_t *e2); struct function_s; expr_t *branch_expr (int op, expr_t *test, expr_t *label); expr_t *goto_expr (expr_t *label); +expr_t *jump_table_expr (expr_t *table, expr_t *index); +expr_t *call_expr (expr_t *func, expr_t *args, struct type_s *ret_type); expr_t *return_expr (struct function_s *f, expr_t *e); expr_t *conditional_expr (expr_t *cond, expr_t *e1, expr_t *e2); expr_t *incop_expr (int op, expr_t *e, int postop); diff --git a/tools/qfcc/include/expr_names.h b/tools/qfcc/include/expr_names.h index 25ebfe07c..fab5c0fdb 100644 --- a/tools/qfcc/include/expr_names.h +++ b/tools/qfcc/include/expr_names.h @@ -56,6 +56,7 @@ EX_EXPR(compound) ///< compound initializer EX_EXPR(memset) ///< memset needs three params... EX_EXPR(alias) ///< view expression as different type (::ex_alias_t) EX_EXPR(address) ///< address of an lvalue expression (::ex_address_t) -EX_EXPR(assign) ///< assignment of src expr to dst expr +EX_EXPR(assign) ///< assignment of src expr to dst expr (::ex_assing_t) +EX_EXPR(branch) ///< branch expression (::ex_branch_t) ///@} diff --git a/tools/qfcc/source/constfold.c b/tools/qfcc/source/constfold.c index 520693b01..92ae4c330 100644 --- a/tools/qfcc/source/constfold.c +++ b/tools/qfcc/source/constfold.c @@ -575,10 +575,6 @@ do_op_field (int op, expr_t *e, expr_t *e1, expr_t *e2) static expr_t * do_op_func (int op, expr_t *e, expr_t *e1, expr_t *e2) { - if (op == 'c') { - e->e.expr.type = get_type (e1)->t.func.type; - return e; - } if (op == EQ || op == NE) { if (options.code.progsversion > PROG_ID_VERSION) e->e.expr.type = &type_integer; @@ -593,7 +589,7 @@ static expr_t * do_op_pointer (int op, expr_t *e, expr_t *e1, expr_t *e2) { type_t *type; - static int valid[] = {'-', 'M', '.', EQ, NE, 0}; + static int valid[] = {'-', '.', EQ, NE, 0}; if (is_integral (type = get_type (e2)) && (op == '-' || op == '+')) { // pointer arithmetic @@ -623,8 +619,7 @@ do_op_pointer (int op, expr_t *e, expr_t *e1, expr_t *e2) else e->e.expr.type = &type_float; } - if (op != '.' && op != 'M' - && extract_type (e1) != extract_type (e2)) + if (op != '.' && extract_type (e1) != extract_type (e2)) return type_mismatch (e1, e2, op); if (op == '.' && is_uinteger(get_type (e2))) e->e.expr.e2 = cf_cast_expr (&type_integer, e2); @@ -993,14 +988,7 @@ do_op_short (int op, expr_t *e, expr_t *e1, expr_t *e2) static expr_t * do_op_struct (int op, expr_t *e, expr_t *e1, expr_t *e2) { - type_t *type; - - if (op != 'm') - return error (e1, "invalid operator for struct"); - if ((type = get_type (e1)) != get_type (e2)) - return type_mismatch (e1, e2, op); - e->e.expr.type = type; - return e; + return error (e1, "invalid operator for struct"); } static expr_t * @@ -1036,8 +1024,6 @@ do_op_invalid (int op, expr_t *e, expr_t *e1, expr_t *e2) type_t *t1 = get_type (e1); type_t *t2 = get_type (e2); - if (e->e.expr.op == 'm') - return e; // assume the rest of the compiler got it right if (is_scalar (t1) && is_scalar (t2)) { // one or both expressions are an enum, and the other is one of // int, float or short. Treat the enum as the other type, or as @@ -1694,7 +1680,7 @@ fold_constants (expr_t *e) return e; } op = e->e.expr.op; - if (op == 'g' || op == 'r') + if (op == 'r') return e; t1 = extract_type (e1); if (t1 >= ev_type_count || !do_unary_op[t1]) { @@ -1710,9 +1696,6 @@ fold_constants (expr_t *e) } op = e->e.expr.op; - if (op == 'i' || op == 'n' || op == 'c') { - return e; - } t1 = extract_type (e1); t2 = extract_type (e2); diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index 95c6807f1..a29920881 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -89,18 +89,8 @@ get_op_string (int op) case SHL: return "<<"; case SHR: return ">>"; case '.': return "."; - case 'i': return ""; - case 'n': return ""; - case IFBE: return ""; - case IFB: return ""; - case IFAE: return ""; - case IFA: return ""; - case 'g': return ""; case 'r': return ""; - case 'c': return ""; case 'C': return ""; - case 'M': return ""; - case 'm': return ""; default: return "unknown"; } @@ -255,62 +245,17 @@ print_block (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) } } -static void -print_call (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) -{ - int indent = level * 2 + 2; - expr_t *p; - int i, count; - expr_t **args; - - for (count = 0, p = e->e.expr.e2; p; p = p->next) - count++; - args = alloca (count * sizeof (expr_t *)); - for (i = 0, p = e->e.expr.e2; p; p = p->next, i++) - args[count - 1 - i] = p; - - _print_expr (dstr, e->e.expr.e1, level, id, next); - dasprintf (dstr, "%*se_%p [label=\"call", indent, "", e); - for (i = 0; i < count; i++) - dasprintf (dstr, "|p%d", i, i); - dasprintf (dstr, "\",shape=record];\n"); - for (i = 0; i < count; i++) { - _print_expr (dstr, args[i], level + 1, id, next); - dasprintf (dstr, "%*se_%p:p%d -> e_%p;\n", indent + 2, "", e, i, - args[i]); - } - dasprintf (dstr, "%*se_%p:c -> e_%p;\n", indent, "", e, e->e.expr.e1); -} - static void print_subexpr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) { int indent = level * 2 + 2; - if (e->e.expr.op == 'c') { - print_call (dstr, e, level, id, next); - return; - } else if (e->e.expr.op == 'i' || e->e.expr.op == 'n' - || e->e.expr.op == IFB || e->e.expr.op ==IFBE - || e->e.expr.op == IFA || e->e.expr.op ==IFAE) { - _print_expr (dstr, e->e.expr.e1, level, id, next); - dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"t\"];\n", indent, "", e, - e->e.expr.e1); - dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"g\"];\n", indent, "", e, - e->e.expr.e2); - if (e->next) - next = e->next; - if (next) - dasprintf (dstr, "%*se_%p -> e_%p [constraint=true," - "style=dashed];\n", indent, "", e, next); - } else { - _print_expr (dstr, e->e.expr.e1, level, id, next); - _print_expr (dstr, e->e.expr.e2, level, id, next); - dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"l\"];\n", indent, "", e, - e->e.expr.e1); - dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"r\"];\n", indent, "", e, - e->e.expr.e2); - } + _print_expr (dstr, e->e.expr.e1, level, id, next); + _print_expr (dstr, e->e.expr.e2, level, id, next); + dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"l\"];\n", indent, "", e, + e->e.expr.e1); + dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"r\"];\n", indent, "", e, + e->e.expr.e2); dasprintf (dstr, "%*se_%p [label=\"%s\\n%d\"];\n", indent, "", e, get_op_string (e->e.expr.op), e->line); } @@ -373,13 +318,94 @@ print_assign (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) "=", e->line); } +static void +print_conditional (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) +{ + int indent = level * 2 + 2; + static const char *condition[] = { + "ifz", "ifb", "ifa", 0, "ifnz", "ifnb", "ifna", 0 + }; + + _print_expr (dstr, e->e.branch.test, level, id, next); + dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"t\"];\n", indent, "", e, + e->e.branch.test); + dasprintf (dstr, "%*se_%p -> \"e_%p\" [label=\"g\"];\n", indent, "", e, + e->e.branch.target); + if (e->next) { + next = e->next; + } + if (next) { + dasprintf (dstr, "%*se_%p -> e_%p [constraint=true," + "style=dashed];\n", indent, "", e, next); + } + dasprintf (dstr, "%*se_%p [label=\"%s\\n%d\"];\n", indent, "", e, + condition [e->e.branch.type], e->line); +} + +static void +print_jump (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) +{ + int indent = level * 2 + 2; + + _print_expr (dstr, e->e.branch.target, level, id, next); + dasprintf (dstr, "%*se_%p [label=\"%s\\n%d\"];\n", indent, "", e, + "jump", e->line); +} + +static void +print_call (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) +{ + int indent = level * 2 + 2; + expr_t *p; + int i, count; + expr_t **args; + + for (count = 0, p = e->e.branch.args; p; p = p->next) + count++; + args = alloca (count * sizeof (expr_t *)); + for (i = 0, p = e->e.branch.args; p; p = p->next, i++) + args[count - 1 - i] = p; + + _print_expr (dstr, e->e.branch.target, level, id, next); + dasprintf (dstr, "%*se_%p [label=\"call", indent, "", e); + for (i = 0; i < count; i++) + dasprintf (dstr, "|p%d", i, i); + dasprintf (dstr, "\",shape=record];\n"); + for (i = 0; i < count; i++) { + _print_expr (dstr, args[i], level + 1, id, next); + dasprintf (dstr, "%*se_%p:p%d -> e_%p;\n", indent + 2, "", e, i, + args[i]); + } + dasprintf (dstr, "%*se_%p:c -> e_%p;\n", indent, "", e, + e->e.branch.target); +} + +static void +print_branch (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) +{ + switch (e->e.branch.type) { + case pr_branch_eq: + case pr_branch_lt: + case pr_branch_gt: + case pr_branch_ne: + case pr_branch_ge: + case pr_branch_le: + print_conditional (dstr, e, level, id, next); + break; + case pr_branch_jump: + print_jump (dstr, e, level, id, next); + break; + case pr_branch_call: + print_call (dstr, e, level, id, next); + break; + } +} + static void print_uexpr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) { int indent = level * 2 + 2; - if (e->e.expr.op != 'g' && e->e.expr.e1) - _print_expr (dstr, e->e.expr.e1, level, id, next); if (e->e.expr.op != 'r' || e->e.expr.e1) dasprintf (dstr, "%*se_%p -> \"e_%p\";\n", indent, "", e, e->e.expr.e1); @@ -618,6 +644,7 @@ _print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) [ex_alias] = print_alias, [ex_address] = print_address, [ex_assign] = print_assign, + [ex_branch] = print_branch, }; int indent = level * 2 + 2; diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 6749422c0..06f4ba944 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -215,8 +215,10 @@ get_type (expr_t *e) const type_t *type = 0; convert_name (e); switch (e->type) { + case ex_branch: case ex_labelref: - return &type_void; + type = e->e.branch.ret_type; + break; case ex_memset: return e->e.memset.type; case ex_label: @@ -495,6 +497,13 @@ copy_expr (expr_t *e) n->e.assign.dst = copy_expr (e->e.assign.dst); n->e.assign.src = copy_expr (e->e.assign.src); return n; + case ex_branch: + n = new_expr (); + *n = *e; + n->e.branch.target = copy_expr (e->e.branch.target); + n->e.branch.test = copy_expr (e->e.branch.test); + n->e.branch.args = copy_expr (e->e.branch.args); + return n; case ex_count: break; } @@ -1591,14 +1600,10 @@ has_function_call (expr_t *e) return 1; return 0; case ex_expr: - if (e->e.expr.op == 'c') - return 1; return (has_function_call (e->e.expr.e1) || has_function_call (e->e.expr.e2)); case ex_uexpr: - if (e->e.expr.op != 'g') - return has_function_call (e->e.expr.e1); - return 0; + return has_function_call (e->e.expr.e1); case ex_alias: return has_function_call (e->e.alias.expr); case ex_address: @@ -1606,6 +1611,14 @@ has_function_call (expr_t *e) case ex_assign: return (has_function_call (e->e.assign.dst) || has_function_call (e->e.assign.src)); + case ex_branch: + if (e->e.branch.type == pr_branch_call) { + return 1; + } + if (e->e.branch.type == pr_branch_jump) { + return 0; + } + return has_function_call (e->e.branch.test); case ex_error: case ex_state: case ex_label: @@ -1724,6 +1737,8 @@ unary_expr (int op, expr_t *e) n->e.expr.type = get_type (e); return n; } + case ex_branch: + return error (e, "invalid type for unary -"); case ex_expr: case ex_bool: case ex_temp: @@ -1826,6 +1841,7 @@ unary_expr (int op, expr_t *e) n->e.expr.type = &type_float; return n; } + case ex_branch: case ex_nil: return error (e, "invalid type for unary !"); case ex_count: @@ -1887,6 +1903,8 @@ unary_expr (int op, expr_t *e) if (!e->e.block.result) return error (e, "invalid type for unary ~"); goto bitnot_expr; + case ex_branch: + return error (e, "invalid type for unary ~"); case ex_expr: case ex_bool: case ex_def: @@ -2072,8 +2090,7 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) e = expr_file_line (e, arg_exprs[arg_expr_count - 1][0]); append_expr (call, e); } - e = expr_file_line (new_binary_expr ('c', fexpr, args), fexpr); - e->e.expr.type = ftype->t.func.type; + e = expr_file_line (call_expr (fexpr, args, ftype->t.func.type), fexpr); append_expr (call, e); if (!is_void(ftype->t.func.type)) { call->e.block.result = new_ret_expr (ftype->t.func.type); @@ -2118,21 +2135,70 @@ function_expr (expr_t *fexpr, expr_t *params) expr_t * branch_expr (int op, expr_t *test, expr_t *label) { - if (label && label->type != ex_label) + // need to translated op due to precedence rules dictating the layout + // of the token ids + static pr_branch_e branch_type [] = { + pr_branch_eq, + pr_branch_ne, + pr_branch_lt, + pr_branch_gt, + pr_branch_le, + pr_branch_ge, + }; + if (op < EQ || op > LE) { + internal_error (label, "invalid op: %d", op); + } + if (label && label->type != ex_label) { internal_error (label, "not a label"); - if (label) + } + if (label) { label->e.label.used++; - return new_binary_expr (op, test, label); + } + expr_t *branch = new_expr (); + branch->type = ex_branch; + branch->e.branch.type = branch_type[op - EQ]; + branch->e.branch.target = label; + branch->e.branch.test = test; + return branch; } expr_t * goto_expr (expr_t *label) { - if (label && label->type != ex_label) + if (label && label->type != ex_label) { internal_error (label, "not a label"); - if (label) + } + if (label) { label->e.label.used++; - return new_unary_expr ('g', label); + } + expr_t *branch = new_expr (); + branch->type = ex_branch; + branch->e.branch.type = pr_branch_jump; + branch->e.branch.target = label; + return branch; +} + +expr_t * +jump_table_expr (expr_t *table, expr_t *index) +{ + expr_t *branch = new_expr (); + branch->type = ex_branch; + branch->e.branch.type = pr_branch_jump; + branch->e.branch.target = table;//FIXME separate? all branch types can + branch->e.branch.index = index; + return branch; +} + +expr_t * +call_expr (expr_t *func, expr_t *args, type_t *ret_type) +{ + expr_t *branch = new_expr (); + branch->type = ex_branch; + branch->e.branch.type = pr_branch_call; + branch->e.branch.target = func; + branch->e.branch.args = args; + branch->e.branch.ret_type = ret_type; + return branch; } expr_t * diff --git a/tools/qfcc/source/expr_assign.c b/tools/qfcc/source/expr_assign.c index 24ce2e349..ed23270c1 100644 --- a/tools/qfcc/source/expr_assign.c +++ b/tools/qfcc/source/expr_assign.c @@ -124,6 +124,7 @@ is_lvalue (const expr_t *expr) return 1; } break; + case ex_branch: case ex_memset: case ex_compound: case ex_state: diff --git a/tools/qfcc/source/expr_bool.c b/tools/qfcc/source/expr_bool.c index 3861951db..9f7b0e1e4 100644 --- a/tools/qfcc/source/expr_bool.c +++ b/tools/qfcc/source/expr_bool.c @@ -165,12 +165,9 @@ backpatch (ex_list_t *list, expr_t *label) for (i = 0; i < list->size; i++) { e = list->e[i]; - if (e->type == ex_uexpr && e->e.expr.op == 'g') - e->e.expr.e1 = label; - else if (e->type == ex_expr && (e->e.expr.op == 'i' - || e->e.expr.op == 'n')) - e->e.expr.e2 = label; - else { + if (e->type == ex_branch && e->e.branch.type < pr_branch_call) { + e->e.branch.target = label; + } else { internal_error (e, 0); } label->e.label.used++; @@ -299,7 +296,7 @@ convert_bool (expr_t *e, int block) e = new_bool_expr (0, make_list (b), b); } else { b = new_block_expr (); - append_expr (b, branch_expr ('i', e, 0)); + append_expr (b, branch_expr (NE, e, 0)); append_expr (b, goto_expr (0)); e = new_bool_expr (make_list (b->e.block.head), make_list (b->e.block.head->next), b); diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index f75621a17..9c56a5790 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -132,7 +132,7 @@ int yylex (void); %left '^' %left '&' %left EQ NE -%left LE GE LT GT +%left LT GT GE LE // end of tokens common between qc and qp %left SHL SHR @@ -146,7 +146,7 @@ int yylex (void); %token VALUE STRING %token LOCAL RETURN WHILE DO IF ELSE FOR BREAK CONTINUE ELLIPSIS -%token NIL IFBE IFB IFAE IFA GOTO SWITCH CASE DEFAULT ENUM +%token NIL GOTO SWITCH CASE DEFAULT ENUM %token ARGS TYPEDEF EXTERN STATIC SYSTEM NOSAVE OVERLOAD NOT %token STRUCT %token TYPE diff --git a/tools/qfcc/source/qp-parse.y b/tools/qfcc/source/qp-parse.y index 28f54bb87..59ddaceec 100644 --- a/tools/qfcc/source/qp-parse.y +++ b/tools/qfcc/source/qp-parse.y @@ -113,7 +113,7 @@ int yylex (void); %left '^' %left '&' %left EQ NE -%left LE GE LT GT +%left LT GT GE LE // end of tokens common between qc and qp %left RELOP diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index a4cfe4626..76caa4eaf 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -588,12 +588,6 @@ convert_op (int op) case SHL: return "<<"; case SHR: return ">>"; case '.': return "."; - case 'i': return ""; - case 'n': return ""; - case IFBE: return ""; - case IFB: return ""; - case IFAE: return ""; - case IFA: return ""; default: return 0; } @@ -709,33 +703,6 @@ static sblock_t *statement_subexpr (sblock_t *sblock, expr_t *e, operand_t **op); static sblock_t *statement_slist (sblock_t *sblock, expr_t *e); -static sblock_t * -statement_branch (sblock_t *sblock, expr_t *e) -{ - statement_t *s = 0; - const char *opcode; - - if (e->type == ex_uexpr && e->e.expr.op == 'g') { - s = new_statement (st_flow, "", e); - s->opa = label_operand (e->e.expr.e1); - } else { - if (e->e.expr.op == 'g') { - s = new_statement (st_flow, "", e); - sblock = statement_subexpr (sblock, e->e.expr.e1, &s->opa); - sblock = statement_subexpr (sblock, e->e.expr.e2, &s->opb); - } else { - opcode = convert_op (e->e.expr.op); - s = new_statement (st_flow, opcode, e); - sblock = statement_subexpr (sblock, e->e.expr.e1, &s->opa); - s->opb = label_operand (e->e.expr.e2); - } - } - - sblock_add_statement (sblock, s); - sblock->next = new_sblock (); - return sblock->next; -} - static sblock_t * expr_address (sblock_t *sblock, expr_t *e, operand_t **op) { @@ -1047,12 +1014,11 @@ vector_call (sblock_t *sblock, expr_t *earg, expr_t *param, int ind, return sblock; } - static sblock_t * expr_call (sblock_t *sblock, expr_t *call, operand_t **op) { - expr_t *func = call->e.expr.e1; - expr_t *args = call->e.expr.e2; + expr_t *func = call->e.branch.target; + expr_t *args = call->e.branch.args; expr_t *a; expr_t *param; operand_t *arguments[2] = {0, 0}; @@ -1113,6 +1079,46 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) return sblock->next; } +static sblock_t * +statement_branch (sblock_t *sblock, expr_t *e) +{ + static const char *opcodes[] = { + "", + "", + "", + 0, // special handling + "", + "", + "", + 0, // not used here + }; + statement_t *s = 0; + const char *opcode; + + if (e->e.branch.type == pr_branch_call) { + return expr_call (sblock, e, 0); + } + if (e->e.branch.type == pr_branch_jump) { + if (e->e.branch.index) { + s = new_statement (st_flow, "", e); + sblock = statement_subexpr (sblock, e->e.branch.target, &s->opa); + sblock = statement_subexpr (sblock, e->e.branch.index, &s->opb); + } else { + s = new_statement (st_flow, "", e); + s->opa = label_operand (e->e.branch.target); + } + } else { + opcode = opcodes [e->e.branch.type]; + s = new_statement (st_flow, opcode, e); + sblock = statement_subexpr (sblock, e->e.branch.test, &s->opa); + s->opb = label_operand (e->e.branch.target); + } + + sblock_add_statement (sblock, s); + sblock->next = new_sblock (); + return sblock->next; +} + static statement_t * lea_statement (operand_t *pointer, operand_t *offset, expr_t *e) { @@ -1261,9 +1267,6 @@ expr_expr (sblock_t *sblock, expr_t *e, operand_t **op) statement_t *s; switch (e->e.expr.op) { - case 'c': - sblock = expr_call (sblock, e, op); - break; case 'm': case 'M': sblock = expr_move (sblock, e, op); @@ -1573,27 +1576,20 @@ build_bool_block (expr_t *block, expr_t *e) e->next = 0; append_expr (block, e); return; + case ex_branch: + e->next = 0; + append_expr (block, e); + return; case ex_expr: if (e->e.expr.op == OR || e->e.expr.op == AND) { build_bool_block (block, e->e.expr.e1); build_bool_block (block, e->e.expr.e2); - } else if (e->e.expr.op == 'i') { - e->next = 0; - append_expr (block, e); - } else if (e->e.expr.op == 'n') { - e->next = 0; - append_expr (block, e); } else { e->next = 0; append_expr (block, e); } return; case ex_uexpr: - if (e->e.expr.op == 'g') { - e->next = 0; - append_expr (block, e); - return; - } break; case ex_block: if (!e->e.block.result) { @@ -1614,19 +1610,20 @@ build_bool_block (expr_t *block, expr_t *e) static int is_goto_expr (expr_t *e) { - return e && e->type == ex_uexpr && e->e.expr.op == 'g'; + return e && e->type == ex_branch && e->e.branch.type == pr_branch_jump + && !e->e.branch.index; } static int is_if_expr (expr_t *e) { - return e && e->type == ex_expr && e->e.expr.op == 'i'; + return e && e->type == ex_branch && e->e.branch.type == pr_branch_ne; } static int is_ifnot_expr (expr_t *e) { - return e && e->type == ex_expr && e->e.expr.op == 'n'; + return e && e->type == ex_branch && e->e.branch.type == pr_branch_eq; } static sblock_t * @@ -1641,33 +1638,33 @@ statement_bool (sblock_t *sblock, expr_t *e) s = &block->e.block.head; while (*s) { if (is_if_expr (*s) && is_goto_expr ((*s)->next)) { - l = (*s)->e.expr.e2; + l = (*s)->e.branch.target; for (e = (*s)->next->next; e && e->type == ex_label; e = e->next) { if (e == l) { l->e.label.used--; e = *s; - e->e.expr.op = 'n'; - e->e.expr.e2 = e->next->e.expr.e1; + e->e.branch.type = pr_branch_eq; + e->e.branch.target = e->next->e.branch.target; e->next = e->next->next; break; } } s = &(*s)->next; } else if (is_ifnot_expr (*s) && is_goto_expr ((*s)->next)) { - l = (*s)->e.expr.e2; + l = (*s)->e.branch.target; for (e = (*s)->next->next; e && e->type == ex_label; e = e->next) { if (e == l) { l->e.label.used--; e = *s; - e->e.expr.op = 'i'; - e->e.expr.e2 = e->next->e.expr.e1; + e->e.branch.type = pr_branch_ne; + e->e.branch.target = e->next->e.branch.target; e->next = e->next->next; break; } } s = &(*s)->next; } else if (is_goto_expr (*s)) { - l = (*s)->e.expr.e1; + l = (*s)->e.branch.target; for (e = (*s)->next; e && e->type == ex_label; e = e->next) { if (e == l) { l->e.label.used--; @@ -1722,18 +1719,6 @@ static sblock_t * statement_expr (sblock_t *sblock, expr_t *e) { switch (e->e.expr.op) { - case 'c': - sblock = expr_call (sblock, e, 0); - break; - case 'g': - case 'i': - case 'n': - case IFBE: - case IFB: - case IFAE: - case IFA: - sblock = statement_branch (sblock, e); - break; case 'm': case 'M': sblock = expr_move (sblock, e, 0); @@ -1776,9 +1761,6 @@ statement_uexpr (sblock_t *sblock, expr_t *e) sblock->next = new_sblock (); sblock = sblock->next; break; - case 'g': - sblock = statement_branch (sblock, e); - break; default: debug (e, "e ue %d", e->e.expr.op); if (options.warnings.executable) @@ -1847,6 +1829,7 @@ statement_slist (sblock_t *sblock, expr_t *e) [ex_value] = statement_nonexec, [ex_memset] = statement_memset, [ex_assign] = statement_assign, + [ex_branch] = statement_branch, }; for (/**/; e; e = e->next) { @@ -2115,24 +2098,19 @@ search_for_super_dealloc (sblock_t *sblock) if (!statement_is_call (st)) { continue; } + // effectively checks target if (st->opa->op_type != op_def || strcmp (st->opa->def->name, "obj_msgSend_super") != 0) { continue; } - // FIXME this is messy (calls should have their own expression - // type) - // have effectively checked e1 above - if (st->expr->type != ex_expr) { - continue; - } // function arguments are in reverse order, and the selector // is the second argument (or second last in the list) expr_t *arg; - for (arg = st->expr->e.expr.e2; + for (arg = st->expr->e.branch.args; arg && arg->next && arg->next->next; arg = arg->next) { } if (arg && arg->next && is_selector (arg)) { - selector_t *sel = get_selector (st->expr->e.expr.e2); + selector_t *sel = get_selector (st->expr->e.branch.args); if (sel && strcmp (sel->name, "dealloc") == 0) { op = pseudo_operand (super_dealloc, st->expr); op->next = st->use; diff --git a/tools/qfcc/source/switch.c b/tools/qfcc/source/switch.c index e1b6d4aa7..190d92a1b 100644 --- a/tools/qfcc/source/switch.c +++ b/tools/qfcc/source/switch.c @@ -311,12 +311,12 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val, append_expr (sw, test); if (tree->low == tree->high) { - branch = branch_expr ('n', new_alias_expr (&type_integer, temp), + branch = branch_expr (EQ, new_alias_expr (&type_integer, temp), tree->labels[0]); append_expr (sw, branch); if (tree->left) { - branch = branch_expr (IFA, new_alias_expr (&type_integer, temp), + branch = branch_expr (GT, new_alias_expr (&type_integer, temp), high_label); append_expr (sw, branch); @@ -352,14 +352,14 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val, table_expr = new_symbol_expr (table_sym); if (tree->left) { - branch = branch_expr (IFB, temp, low_label); + branch = branch_expr (LT, temp, low_label); append_expr (sw, branch); } test = binary_expr (GT, cast_expr (&type_uinteger, temp), cast_expr (&type_uinteger, range)); - branch = branch_expr ('i', test, high_label); + branch = branch_expr (NE, test, high_label); append_expr (sw, branch); - branch = new_binary_expr ('g', table_expr, temp); + branch = jump_table_expr (table_expr, temp); append_expr (sw, branch); debug (sw, "switch using jump table"); if (tree->left) { @@ -433,7 +433,7 @@ switch_expr (switch_block_t *switch_block, expr_t *break_label, || num_labels < 8) { for (l = labels; *l; l++) { expr_t *cmp = binary_expr (EQ, sw_val, (*l)->value); - expr_t *test = branch_expr ('i', test_expr (cmp), + expr_t *test = branch_expr (NE, test_expr (cmp), (*l)->label); append_expr (sw, test); From 66528e34fc9dcbf2220ad8a3754a9cb9dd1e264a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 9 Jan 2022 16:28:08 +0900 Subject: [PATCH 079/360] [qfcc] Give return expressions their own type Very simple for now (just the return value if not a void return), but that's the last of the statements masquerading as expressions. --- tools/qfcc/include/expr.h | 6 ++ tools/qfcc/include/expr_names.h | 1 + tools/qfcc/source/constfold.c | 2 - tools/qfcc/source/dot_expr.c | 19 ++++- tools/qfcc/source/expr.c | 45 +++++++---- tools/qfcc/source/expr_assign.c | 1 + tools/qfcc/source/qp-parse.y | 2 +- tools/qfcc/source/statements.c | 138 +++++++++++--------------------- 8 files changed, 100 insertions(+), 114 deletions(-) diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index ff8c25cf7..59ac358e4 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -233,6 +233,10 @@ typedef struct { struct type_s *ret_type; ///< void for non-call } ex_branch_t; +typedef struct { + struct expr_s *ret_val; +} ex_return_t; + #define POINTER_VAL(p) (((p).def ? (p).def->offset : 0) + (p).val) typedef struct expr_s { @@ -263,6 +267,7 @@ typedef struct expr_s { ex_address_t address; ///< alias expr params ex_assign_t assign; ///< assignment expr params ex_branch_t branch; ///< branch expr params + ex_return_t retrn; ///< return expr params struct type_s *nil; ///< type for nil if known } e; } expr_t; @@ -680,6 +685,7 @@ expr_t *new_offset_alias_expr (struct type_s *type, expr_t *expr, int offset); expr_t *new_address_expr (struct type_s *lvtype, expr_t *lvalue, expr_t *offset); expr_t *new_assign_expr (expr_t *dst, expr_t *src); +expr_t *new_return_expr (expr_t *ret_val); /** Create an expression of the correct type that references the specified parameter slot. diff --git a/tools/qfcc/include/expr_names.h b/tools/qfcc/include/expr_names.h index fab5c0fdb..08285c94a 100644 --- a/tools/qfcc/include/expr_names.h +++ b/tools/qfcc/include/expr_names.h @@ -58,5 +58,6 @@ EX_EXPR(alias) ///< view expression as different type (::ex_alias_t) EX_EXPR(address) ///< address of an lvalue expression (::ex_address_t) EX_EXPR(assign) ///< assignment of src expr to dst expr (::ex_assing_t) EX_EXPR(branch) ///< branch expression (::ex_branch_t) +EX_EXPR(return) ///< return expression (::ex_return_t) ///@} diff --git a/tools/qfcc/source/constfold.c b/tools/qfcc/source/constfold.c index 92ae4c330..6ee98f70e 100644 --- a/tools/qfcc/source/constfold.c +++ b/tools/qfcc/source/constfold.c @@ -1680,8 +1680,6 @@ fold_constants (expr_t *e) return e; } op = e->e.expr.op; - if (op == 'r') - return e; t1 = extract_type (e1); if (t1 >= ev_type_count || !do_unary_op[t1]) { print_expr (e); diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index a29920881..a66009bd5 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -89,7 +89,6 @@ get_op_string (int op) case SHL: return "<<"; case SHR: return ">>"; case '.': return "."; - case 'r': return ""; case 'C': return ""; default: return "unknown"; @@ -401,14 +400,25 @@ print_branch (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) } } +static void +print_return (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) +{ + int indent = level * 2 + 2; + + if (e->e.retrn.ret_val) { + dasprintf (dstr, "%*se_%p -> \"e_%p\";\n", indent, "", e, + e->e.retrn.ret_val); + } + dasprintf (dstr, "%*se_%p [label=\"%s\\n%d\"];\n", indent, "", e, + "return", e->line); +} + static void print_uexpr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) { int indent = level * 2 + 2; - if (e->e.expr.op != 'r' || e->e.expr.e1) - dasprintf (dstr, "%*se_%p -> \"e_%p\";\n", indent, "", e, - e->e.expr.e1); + dasprintf (dstr, "%*se_%p -> \"e_%p\";\n", indent, "", e, e->e.expr.e1); dasprintf (dstr, "%*se_%p [label=\"%s\\n%d\"];\n", indent, "", e, get_op_string (e->e.expr.op), e->line); } @@ -645,6 +655,7 @@ _print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) [ex_address] = print_address, [ex_assign] = print_assign, [ex_branch] = print_branch, + [ex_return] = print_return, }; int indent = level * 2 + 2; diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 06f4ba944..ae3f919dc 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -221,10 +221,12 @@ get_type (expr_t *e) break; case ex_memset: return e->e.memset.type; - case ex_label: case ex_error: + case ex_return: + internal_error (e, "unexpected expression type"); + case ex_label: case ex_compound: - return 0; // something went very wrong + return 0; case ex_bool: if (options.code.progsversion == PROG_ID_VERSION) return &type_float; @@ -504,6 +506,11 @@ copy_expr (expr_t *e) n->e.branch.test = copy_expr (e->e.branch.test); n->e.branch.args = copy_expr (e->e.branch.args); return n; + case ex_return: + n = new_expr (); + *n = *e; + n->e.retrn.ret_val = copy_expr (n->e.retrn.ret_val); + return n; case ex_count: break; } @@ -1325,6 +1332,15 @@ new_assign_expr (expr_t *dst, expr_t *src) return addr; } +expr_t * +new_return_expr (expr_t *ret_val) +{ + expr_t *retrn = new_expr (); + retrn->type = ex_return; + retrn->e.retrn.ret_val = ret_val; + return retrn; +} + static expr_t * param_expr (const char *name, type_t *type) { @@ -1619,6 +1635,8 @@ has_function_call (expr_t *e) return 0; } return has_function_call (e->e.branch.test); + case ex_return: + return has_function_call (e->e.retrn.ret_val); case ex_error: case ex_state: case ex_label: @@ -1716,7 +1734,8 @@ unary_expr (int op, expr_t *e) case ex_compound: case ex_memset: case ex_selector: - internal_error (e, 0); + case ex_return: + internal_error (e, "unexpected expression type"); case ex_uexpr: if (e->e.expr.op == '-') { return e->e.expr.e1; @@ -1816,7 +1835,8 @@ unary_expr (int op, expr_t *e) case ex_compound: case ex_memset: case ex_selector: - internal_error (e, 0); + case ex_return: + internal_error (e, "unexpected expression type"); case ex_bool: return new_bool_expr (e->e.bool.false_list, e->e.bool.true_list, e); @@ -1894,7 +1914,8 @@ unary_expr (int op, expr_t *e) case ex_compound: case ex_memset: case ex_selector: - internal_error (e, 0); + case ex_return: + internal_error (e, "unexpected expression type"); case ex_uexpr: if (e->e.expr.op == '~') return e->e.expr.e1; @@ -2222,7 +2243,7 @@ return_expr (function_t *f, expr_t *e) } // the traditional check above may have set e if (!e) { - return new_unary_expr ('r', 0); + return new_return_expr (0); } } @@ -2279,7 +2300,7 @@ return_expr (function_t *f, expr_t *e) if (e->type == ex_block) { e->e.block.result->rvalue = 1; } - return new_unary_expr ('r', e); + return new_return_expr (e); } expr_t * @@ -2471,16 +2492,6 @@ address_expr (expr_t *e1, expr_t *e2, type_t *t) e1->e.expr.e1, e1->e.expr.e2); break; } - if (e1->e.expr.op == 'm') { - // direct move, so obtain the address of the source - e = address_expr (e1->e.expr.e2, 0, t); - break; - } - if (e1->e.expr.op == 'M') { - // indirect move, so we already have the address of the source - e = e1->e.expr.e2; - break; - } return error (e1, "invalid type for unary &"); case ex_uexpr: if (e1->e.expr.op == '.') { diff --git a/tools/qfcc/source/expr_assign.c b/tools/qfcc/source/expr_assign.c index ed23270c1..a961e113d 100644 --- a/tools/qfcc/source/expr_assign.c +++ b/tools/qfcc/source/expr_assign.c @@ -137,6 +137,7 @@ is_lvalue (const expr_t *expr) case ex_value: case ex_error: case ex_selector: + case ex_return: break; case ex_count: internal_error (expr, "invalid expression"); diff --git a/tools/qfcc/source/qp-parse.y b/tools/qfcc/source/qp-parse.y index 59ddaceec..b45e6d0ee 100644 --- a/tools/qfcc/source/qp-parse.y +++ b/tools/qfcc/source/qp-parse.y @@ -270,7 +270,7 @@ subprogram_declaration } declarations compound_statement ';' { - append_expr ($5, new_unary_expr ('r', 0)); + append_expr ($5, new_return_expr (0)); build_code_function ($1, 0, $5); current_symtab = current_symtab->parent; current_storage = $3; diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 76caa4eaf..1c2cbc965 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -963,35 +963,6 @@ dereference_dst: return sblock; } -static sblock_t * -expr_move (sblock_t *sblock, expr_t *e, operand_t **op) -{ - statement_t *s; - type_t *type = e->e.expr.type; - expr_t *dst_expr = e->e.expr.e1; - expr_t *src_expr = e->e.expr.e2; - expr_t *size_expr; - operand_t *dst = 0; - operand_t *src = 0; - operand_t *size = 0; - - if (!op) - op = &dst; - size_expr = new_short_expr (type_size (type)); - sblock = statement_subexpr (sblock, dst_expr, op); - dst = *op; - sblock = statement_subexpr (sblock, src_expr, &src); - sblock = statement_subexpr (sblock, size_expr, &size); - s = new_statement (e->e.expr.op == 'm' ? st_move : st_ptrmove, - convert_op (e->e.expr.op), e); - s->opa = src; - s->opb = size; - s->opc = dst; - sblock_add_statement (sblock, s); - - return sblock; -} - static sblock_t * vector_call (sblock_t *sblock, expr_t *earg, expr_t *param, int ind, operand_t **op) @@ -1119,6 +1090,33 @@ statement_branch (sblock_t *sblock, expr_t *e) return sblock->next; } +static sblock_t * +statement_return (sblock_t *sblock, expr_t *e) +{ + const char *opcode; + statement_t *s; + + debug (e, "RETURN"); + opcode = ""; + if (!e->e.retrn.ret_val) { + if (options.code.progsversion != PROG_ID_VERSION) { + opcode = ""; + } else { + e->e.retrn.ret_val = new_float_expr (0); + } + } + s = new_statement (st_func, opcode, e); + if (e->e.retrn.ret_val) { + s->opa = return_operand (get_type (e->e.retrn.ret_val), e); + sblock = statement_subexpr (sblock, e->e.retrn.ret_val, &s->opa); + } + sblock_add_statement (sblock, s); + sblock->next = new_sblock (); + sblock = sblock->next; + + return sblock; +} + static statement_t * lea_statement (operand_t *pointer, operand_t *offset, expr_t *e) { @@ -1266,24 +1264,17 @@ expr_expr (sblock_t *sblock, expr_t *e, operand_t **op) const char *opcode; statement_t *s; - switch (e->e.expr.op) { - case 'm': - case 'M': - sblock = expr_move (sblock, e, op); - break; - default: - opcode = convert_op (e->e.expr.op); - if (!opcode) - internal_error (e, "ice ice baby"); - s = new_statement (st_expr, opcode, e); - sblock = statement_subexpr (sblock, e->e.expr.e1, &s->opa); - sblock = statement_subexpr (sblock, e->e.expr.e2, &s->opb); - if (!*op) - *op = temp_operand (e->e.expr.type, e); - s->opc = *op; - sblock_add_statement (sblock, s); - break; - } + opcode = convert_op (e->e.expr.op); + if (!opcode) + internal_error (e, "ice ice baby"); + s = new_statement (st_expr, opcode, e); + sblock = statement_subexpr (sblock, e->e.expr.e1, &s->opa); + sblock = statement_subexpr (sblock, e->e.expr.e2, &s->opb); + if (!*op) + *op = temp_operand (e->e.expr.type, e); + s->opc = *op; + sblock_add_statement (sblock, s); + return sblock; } @@ -1718,55 +1709,21 @@ statement_block (sblock_t *sblock, expr_t *e) static sblock_t * statement_expr (sblock_t *sblock, expr_t *e) { - switch (e->e.expr.op) { - case 'm': - case 'M': - sblock = expr_move (sblock, e, 0); - break; - default: - if (e->e.expr.op < 256) - debug (e, "e %c", e->e.expr.op); - else - debug (e, "e %d", e->e.expr.op); - if (options.warnings.executable) - warning (e, "Non-executable statement;" - " executing programmer instead."); - } + if (e->e.expr.op < 256) + debug (e, "e %c", e->e.expr.op); + else + debug (e, "e %d", e->e.expr.op); + if (options.warnings.executable) + warning (e, "Non-executable statement; executing programmer instead."); return sblock; } static sblock_t * statement_uexpr (sblock_t *sblock, expr_t *e) { - const char *opcode; - statement_t *s; - - switch (e->e.expr.op) { - case 'r': - debug (e, "RETURN"); - opcode = ""; - if (!e->e.expr.e1) { - if (options.code.progsversion != PROG_ID_VERSION) { - opcode = ""; - } else { - e->e.expr.e1 = new_float_expr (0); - } - } - s = new_statement (st_func, opcode, e); - if (e->e.expr.e1) { - s->opa = return_operand (get_type (e->e.expr.e1), e); - sblock = statement_subexpr (sblock, e->e.expr.e1, &s->opa); - } - sblock_add_statement (sblock, s); - sblock->next = new_sblock (); - sblock = sblock->next; - break; - default: - debug (e, "e ue %d", e->e.expr.op); - if (options.warnings.executable) - warning (e, "Non-executable statement;" - " executing programmer instead."); - } + debug (e, "e ue %d", e->e.expr.op); + if (options.warnings.executable) + warning (e, "Non-executable statement; executing programmer instead."); return sblock; } @@ -1830,6 +1787,7 @@ statement_slist (sblock_t *sblock, expr_t *e) [ex_memset] = statement_memset, [ex_assign] = statement_assign, [ex_branch] = statement_branch, + [ex_return] = statement_return, }; for (/**/; e; e = e->next) { From 494a6908bbc5728f028b40a2b9b5d8bb77d25cef Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 10 Jan 2022 11:04:43 +0900 Subject: [PATCH 080/360] [gamecode] Improve with's comment --- libs/gamecode/opcodes.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 9d71b94e5..5821aa1a1 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -7,7 +7,7 @@ bitmap_txt = """ 0 0110 0nnn rcall 1-8 (0 0100 11mm with 0 params for [r]call0) 0 0110 10ss return 0 0110 1100 returnv -0 0110 1101 with (reg encoded in st->c) +0 0110 1101 with (mode in st->a, value in st->b, reg in st->c) 0 0110 111t state 0 0111 tooo vecops 0 1ccc ttss compare From db7a67e5b78665865e9702d18c3fe4a1ed07a356 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 10 Jan 2022 11:16:55 +0900 Subject: [PATCH 081/360] [gamecode] Rearrange vector instructions This allows the dot products to be consistent with their sizes: cdot is really dot_2, vdot dot_3, and qdot dot_4. --- libs/gamecode/opcodes.py | 2 +- libs/gamecode/pr_exec.c | 32 ++++++++++++++++---------------- 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 5821aa1a1..2c4410eb7 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -454,7 +454,7 @@ vecops_formats = { "widths": "{vec_widths[ooo]}", "types": "{vec_types[t]}, {vec_types[t]}, {vec_types[t]}", "args": { - "op_vop": ["cdot", "vdot", "qdot", "cross", + "op_vop": ["cross", "cdot", "vdot", "qdot", "cmul", "qvmul", "vqmul", "qmul"], "vop_type": ['F', 'D'], "vec_widths": [ diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index f43011a79..d5be92743 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -2959,6 +2959,14 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) } break; // 0 0111 + case OP_CROSS_F: + { + pr_vec4_t a = loadvec3f (&OPA(float)); + pr_vec4_t b = loadvec3f (&OPB(float)); + pr_vec4_t c = crossf (a, b); + storevec3f (&OPC(float), c); + } + break; case OP_CDOT_F: OPC(vec2) = dot2f (OPA(vec2), OPB(vec2)); break; @@ -2972,14 +2980,6 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_QDOT_F: OPC(vec4) = dotf (OPA(vec4), OPB(vec4)); break; - case OP_CROSS_F: - { - pr_vec4_t a = loadvec3f (&OPA(float)); - pr_vec4_t b = loadvec3f (&OPB(float)); - pr_vec4_t c = crossf (a, b); - storevec3f (&OPC(float), c); - } - break; case OP_CMUL_F: OPC(vec2) = cmulf (OPA(vec2), OPB(vec2)); break; @@ -3000,6 +3000,14 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_QMUL_F: OPC(vec4) = qmulf (OPA(vec4), OPB(vec4)); break; + case OP_CROSS_D: + { + pr_dvec4_t a = loadvec3d (&OPA(double)); + pr_dvec4_t b = loadvec3d (&OPB(double)); + pr_dvec4_t c = crossd (a, b); + storevec3d (&OPC(double), c); + } + break; case OP_CDOT_D: OPC(dvec2) = dot2d (OPA(dvec2), OPB(dvec2)); break; @@ -3013,14 +3021,6 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_QDOT_D: OPC(dvec4) = dotd (OPA(dvec4), OPB(dvec4)); break; - case OP_CROSS_D: - { - pr_dvec4_t a = loadvec3d (&OPA(double)); - pr_dvec4_t b = loadvec3d (&OPB(double)); - pr_dvec4_t c = crossd (a, b); - storevec3d (&OPC(double), c); - } - break; case OP_CMUL_D: OPC(dvec2) = cmuld (OPA(dvec2), OPB(dvec2)); break; From ba29be3f82a56a1215511740ee3ad1999b12ca30 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 10 Jan 2022 11:27:57 +0900 Subject: [PATCH 082/360] [gamecode] Rename ifnot and if to be less confusing I think :) anyway, now they're ifz and ifnz, making them consistent with the rest of the if instructions. --- libs/gamecode/opcodes.py | 4 +- libs/gamecode/pr_exec.c | 90 ++++++++++++++++---------------- libs/gamecode/test/test-double.c | 2 +- libs/gamecode/test/test-float.c | 2 +- 4 files changed, 49 insertions(+), 49 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 2c4410eb7..319859f1d 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -114,8 +114,8 @@ branch_formats = { "types": "ev_void, ev_void, ev_integer", "args": { "op_mode": "ABCD", - "op_cond": ["ifnot", "ifb", "ifa", "jump", - "if", "ifae", "ifbe", "call"], + "op_cond": ["ifz", "ifb", "ifa", "jump", + "ifnz", "ifae", "ifbe", "call"], "branch_fmt": branch_fmt, "cond_fmt": ["%Gc ", "%Gc ", "%Gc ", "", "%Gc ", "%Gc ", "%Gc ", ""], "cond_widths": [ diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index d5be92743..3d179c869 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -2819,20 +2819,29 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) MM(ivec4) = STK(ivec4); break; // 0 0100 - case OP_IFNOT_A: - case OP_IFNOT_B: - case OP_IFNOT_C: - case OP_IFNOT_D: + case OP_IFZ_A: + case OP_IFZ_B: + case OP_IFZ_C: + case OP_IFZ_D: if (!OPC(int)) { pr->pr_xstatement = pr_jump_mode (pr, st); st = pr->pr_statements + pr->pr_xstatement; } break; - case OP_IF_A: - case OP_IF_B: - case OP_IF_C: - case OP_IF_D: - if (OPC(int)) { + case OP_IFB_A: + case OP_IFB_B: + case OP_IFB_C: + case OP_IFB_D: + if (OPC(int) < 0) { + pr->pr_xstatement = pr_jump_mode (pr, st); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_IFA_A: + case OP_IFA_B: + case OP_IFA_C: + case OP_IFA_D: + if (OPC(int) > 0) { pr->pr_xstatement = pr_jump_mode (pr, st); st = pr->pr_statements + pr->pr_xstatement; } @@ -2844,6 +2853,33 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) pr->pr_xstatement = pr_jump_mode (pr, st); st = pr->pr_statements + pr->pr_xstatement; break; + case OP_IFNZ_A: + case OP_IFNZ_B: + case OP_IFNZ_C: + case OP_IFNZ_D: + if (OPC(int)) { + pr->pr_xstatement = pr_jump_mode (pr, st); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_IFAE_A: + case OP_IFAE_B: + case OP_IFAE_C: + case OP_IFAE_D: + if (OPC(int) >= 0) { + pr->pr_xstatement = pr_jump_mode (pr, st); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_IFBE_A: + case OP_IFBE_B: + case OP_IFBE_C: + case OP_IFBE_D: + if (OPC(int) <= 0) { + pr->pr_xstatement = pr_jump_mode (pr, st); + st = pr->pr_statements + pr->pr_xstatement; + } + break; case OP_CALL_A: case OP_CALL_B: case OP_CALL_C: @@ -2922,42 +2958,6 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) } break; // 0 0110 - case OP_IFA_A: - case OP_IFA_B: - case OP_IFA_C: - case OP_IFA_D: - if (OPC(int) > 0) { - pr->pr_xstatement = pr_jump_mode (pr, st); - st = pr->pr_statements + pr->pr_xstatement; - } - break; - case OP_IFBE_A: - case OP_IFBE_B: - case OP_IFBE_C: - case OP_IFBE_D: - if (OPC(int) <= 0) { - pr->pr_xstatement = pr_jump_mode (pr, st); - st = pr->pr_statements + pr->pr_xstatement; - } - break; - case OP_IFB_A: - case OP_IFB_B: - case OP_IFB_C: - case OP_IFB_D: - if (OPC(int) < 0) { - pr->pr_xstatement = pr_jump_mode (pr, st); - st = pr->pr_statements + pr->pr_xstatement; - } - break; - case OP_IFAE_A: - case OP_IFAE_B: - case OP_IFAE_C: - case OP_IFAE_D: - if (OPC(int) >= 0) { - pr->pr_xstatement = pr_jump_mode (pr, st); - st = pr->pr_statements + pr->pr_xstatement; - } - break; // 0 0111 case OP_CROSS_F: { diff --git a/libs/gamecode/test/test-double.c b/libs/gamecode/test/test-double.c index 230ba69ee..8e11359ee 100644 --- a/libs/gamecode/test/test-double.c +++ b/libs/gamecode/test/test-double.c @@ -129,7 +129,7 @@ static dstatement_t double_cossin_statements[] = { { OP(0, 0, 0, OP_DIV_D_2), 40, 16, 40 }, // xn /= f { OP(0, 0, 0, OP_ADD_D_2), 16, 24, 16 }, // f += inc { OP(0, 0, 0, OP_LT_D_1), 16, 30, 46 }, // f0 < fmax - { OP(0, 0, 0, OP_IF_A), -7, 0, 46 }, // f0 < fmax + { OP(0, 0, 0, OP_IFNZ_A), -7, 0, 46 }, // f0 < fmax }; test_t tests[] = { diff --git a/libs/gamecode/test/test-float.c b/libs/gamecode/test/test-float.c index d974931bb..8f5794c3d 100644 --- a/libs/gamecode/test/test-float.c +++ b/libs/gamecode/test/test-float.c @@ -129,7 +129,7 @@ static dstatement_t float_cossin_statements[] = { { OP(0, 0, 0, OP_DIV_F_2), 20, 8, 20 }, // xn /= f { OP(0, 0, 0, OP_ADD_F_2), 8, 12, 8 }, // f += inc { OP(0, 0, 0, OP_LT_F_1), 8, 15, 23 }, // f0 < fmax - { OP(0, 0, 0, OP_IF_A), -7, 0, 23 }, // f0 < fmax + { OP(0, 0, 0, OP_IFNZ_A), -7, 0, 23 }, // f0 < fmax }; test_t tests[] = { From b9e32ee2f5058b42631bbe376ee412cf31cf26e2 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 10 Jan 2022 11:38:21 +0900 Subject: [PATCH 083/360] [gamecode] Rework call and return instructions The call1-8 instructions have been removed as they are really not needed (they were put in when I had plans of simple translation of v6p progs to ruamoko, but they joined the dinosaurs). The call instruction lost mode A (that is now return) and its mode B is just the regular function access. The important thing is op_c (with support for with-bases) specifies the location of the return def. The return instruction packs both its addressing mode and return value size into st->c as a 3.5 value: 3 bits for the mode (it supports all five addressing modes with entity.field being mode 4) and 5 for the size, limiting return sizes to 32 words, which is enough for one 4x4 double matrix. This, especially with the following convert patch, frees up a lot of instructions. --- libs/gamecode/opcodes.py | 71 ++++++++++------------ libs/gamecode/pr_exec.c | 123 ++++++++++++++++++++++++++------------- 2 files changed, 116 insertions(+), 78 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 319859f1d..f7745c76c 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -4,9 +4,13 @@ bitmap_txt = """ 0 0010 mmss push 0 0011 mmss pop 0 010c ccmm branch -0 0110 0nnn rcall 1-8 (0 0100 11mm with 0 params for [r]call0) -0 0110 10ss return -0 0110 1100 returnv + +# while call and return are part of the branch block, they have different +# handling for addressing and formatting +0 0101 11mm call (return specified st->c) +0 0101 1100 return (size in st->c) + +0 0110 0nnn 0 0110 1101 with (mode in st->a, value in st->b, reg in st->c) 0 0110 111t state 0 0111 tooo vecops @@ -115,7 +119,7 @@ branch_formats = { "args": { "op_mode": "ABCD", "op_cond": ["ifz", "ifb", "ifa", "jump", - "ifnz", "ifae", "ifbe", "call"], + "ifnz", "ifae", "ifbe", None], #call and return seprate "branch_fmt": branch_fmt, "cond_fmt": ["%Gc ", "%Gc ", "%Gc ", "", "%Gc ", "%Gc ", "%Gc ", ""], "cond_widths": [ @@ -130,6 +134,23 @@ branch_formats = { ], }, } +call_formats = { + "opcode": "OP_CALL_{op_mode[mm]}", + "mnemonic": "call", + "opname": "call", + "format": "{call_fmt[mm]}", + "widths": "0, 0, 0", + "types": "ev_void, ev_void, ev_void", + "args": { + "op_mode": ".BCD", + "call_fmt": [ + None, # return handled seprately + "%Ga, %gc", + "%Ga[%sb], %gc", + "%Ga[%Gb], %gc", + ], + }, +} compare_formats = { "opcode": "OP_{op_cmp[ccc].upper()}_{cmp_type[tt]}_{ss+1}", "mnemonic": "{op_cmp[ccc]}.{cmp_type[tt]}", @@ -411,41 +432,13 @@ swizzle_formats = { "swizzle_types": float_t, }, } -rcall_formats = { - "opcode": "OP_CALL_{nnn+1}", - "mnemonic": "rcall{nnn+1}", - "opname": "rcall{nnn+1}", - "format": "{rcall_fmt[nnn]}", - "widths": "0, 0, 0", - "types": "ev_func, ev_void, ev_void", - "args": { - "rcall_fmt": [ - "%Fa (%P0b)", - "%Fa (%P0b, %P1c)", - "%Fa (%P0b, %P1c, %P2x)", - "%Fa (%P0b, %P1c, %P2x, %P3x)", - "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x)", - "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x)", - "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x)", - "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x, %P7x)", - ], - }, -} return_formats = { - "opcode": "OP_RETURN_{ss+1}", - "mnemonic": "return{ss+1}", - "opname": "return", - "widths": "0, 0, 0", - "format": "%Ra", - "types": "ev_void, ev_invalid, ev_invalid", -} -returnv_formats = { - "opcode": "OP_RETURN_0", + "opcode": "OP_RETURN", "mnemonic": "return", "opname": "return", - "widths": "0, 0, 0", - "format": None, - "types": "ev_invalid, ev_invalid, ev_invalid", + "widths": "0, 0, 0", # width specified by st->c + "format": "FIXME", + "types": "ev_void, ev_void, ev_void", } vecops_formats = { "opcode": "OP_{op_vop[ooo].upper()}_{vop_type[t]}", @@ -497,6 +490,7 @@ group_map = { "bitops": bitops_formats, "boolops": boolops_formats, "branch": branch_formats, + "call": call_formats, "compare": compare_formats, "compare2": compare2_formats, "convert": convert_formats, @@ -518,9 +512,7 @@ group_map = { "store": store_formats, "string": string_formats, "swizzle": swizzle_formats, - "rcall": rcall_formats, "return": return_formats, - "returnv": returnv_formats, "vecops": vecops_formats, "vecops2": vecops2_formats, "with": with_formats, @@ -601,7 +593,8 @@ if len (sys.argv) < 2 or sys.argv[1] not in ["enum", "table"]: lines = bitmap_txt.split('\n') for l in lines: - if not l: + l = l.strip() + if not l or l[0] == '#': continue c = l.split(' ') bits = "".join(c[0:3]) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 3d179c869..66b1f3818 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1793,6 +1793,68 @@ pr_address_mode (progs_t *pr, const dstatement_t *st, int shift) return pr->pr_globals + mm_offs; } +static pr_type_t * +pr_return_mode (progs_t *pr, const dstatement_t *st, int mm_ind) +{ + pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); + pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, B); + pointer_t mm_offs = 0; + + switch (mm_ind) { + case 0: + // regular global access + mm_offs = op_a - pr->pr_globals; + break; + case 1: + // simple pointer dereference: *a + mm_offs = OPA(uint); + break; + case 2: + // constant indexed pointer: *a + b (supports -ve offset) + mm_offs = OPA(uint) + (short) st->b; + break; + case 3: + // variable indexed pointer: *a + *b (supports -ve offset) + mm_offs = OPA(uint) + OPB(int); + break; + case 4: + // entity.field (equivalent to OP_LOAD_t_v6p) + pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; + mm_offs = edict_area + OPA(uint) + OPB(uint); + break; + } + return pr->pr_globals + mm_offs; +} + +static pr_type_t * +pr_call_mode (progs_t *pr, const dstatement_t *st, int mm_ind) +{ + pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); + pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, B); + pointer_t mm_offs = 0; + + switch (mm_ind) { + case 1: + // regular global access + mm_offs = op_a - pr->pr_globals; + break; + case 2: + // constant indexed pointer: *a + b (supports -ve offset) + mm_offs = OPA(uint) + (short) st->b; + break; + case 3: + // variable indexed pointer: *a + *b (supports -ve offset) + mm_offs = OPA(uint) + OPB(int); + break; + case 4: + // entity.field (equivalent to OP_LOAD_t_v6p) + pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; + mm_offs = edict_area + OPA(uint) + OPB(uint); + break; + } + return pr->pr_globals + mm_offs; +} + static pr_pointer_t __attribute__((pure)) pr_jump_mode (progs_t *pr, const dstatement_t *st) { @@ -2880,45 +2942,12 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) st = pr->pr_statements + pr->pr_xstatement; } break; - case OP_CALL_A: - case OP_CALL_B: - case OP_CALL_C: - case OP_CALL_D: - mm = pr_address_mode (pr, st, 0); - function = mm->func_var; - pr->pr_argc = 0; - op_call: - pr->pr_xfunction->profile += profile - startprofile; - startprofile = profile; - PR_CallFunction (pr, function); - st = pr->pr_statements + pr->pr_xstatement; - break; - // 0 0101 - case OP_CALL_2: case OP_CALL_3: case OP_CALL_4: - case OP_CALL_5: case OP_CALL_6: case OP_CALL_7: case OP_CALL_8: - pr->pr_params[1] = op_c; - goto op_call_n; - case OP_CALL_1: - pr->pr_params[1] = pr->pr_real_params[1]; - op_call_n: - pr->pr_params[0] = op_b; - function = op_a->func_var; - pr->pr_argc = st->op - OP_CALL_1 + 1; - goto op_call; - case OP_RETURN_4: - memcpy (&R_INT (pr), op_a, 4 * sizeof (*op_a)); - goto op_return; - case OP_RETURN_3: - memcpy (&R_INT (pr), op_a, 3 * sizeof (*op_a)); - goto op_return; - case OP_RETURN_2: - memcpy (&R_INT (pr), op_a, 2 * sizeof (*op_a)); - goto op_return; - case OP_RETURN_1: - memcpy (&R_INT (pr), op_a, 1 * sizeof (*op_a)); - goto op_return; - case OP_RETURN_0: - op_return: + case OP_RETURN: + int ret_size = st->c & 0x1f; // up to 32 words + if (ret_size) { + mm = pr_return_mode (pr, st, (st->c >> 5) & 7); + memcpy (&R_INT (pr), mm, ret_size * sizeof (*op_a)); + } pr->pr_xfunction->profile += profile - startprofile; startprofile = profile; PR_LeaveFunction (pr, pr->pr_depth == exitdepth); @@ -2930,6 +2959,22 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) goto exit_program; } break; + case OP_CALL_B: + case OP_CALL_C: + case OP_CALL_D: + mm = pr_call_mode (pr, st, st->c & 3); + function = mm->func_var; + pr->pr_argc = 0; + // op_c specifies the location for the return value if any + pr->pr_return = op_c; + pr->pr_xfunction->profile += profile - startprofile; + startprofile = profile; + PR_CallFunction (pr, function); + st = pr->pr_statements + pr->pr_xstatement; + break; + // 0 0101 + // nnn spare + //OP_CONV case OP_WITH: pr->pr_bases[st->c & 3] = pr_with (pr, st); break; From 0fb661958516db7ae2b10b168d1c935e9fca0f11 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 10 Jan 2022 11:53:57 +0900 Subject: [PATCH 084/360] [gamecode] Compact the convert instructions into one Thanks to Deek for the suggestion: the mode (ie, src and dst types) are encoded in st->b. Actual code not written yet, but this frees up 13 instructions: now have 74 available for really interesting stuff :) --- libs/gamecode/opcodes.py | 32 +++++++------------------------- 1 file changed, 7 insertions(+), 25 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index f7745c76c..94c115492 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -11,6 +11,7 @@ bitmap_txt = """ 0 0101 1100 return (size in st->c) 0 0110 0nnn +0 0110 1100 convert (conversion mode in st->b) 0 0110 1101 with (mode in st->a, value in st->b, reg in st->c) 0 0110 111t state 0 0111 tooo vecops @@ -22,7 +23,7 @@ bitmap_txt = """ 1 1000 ooss bitops 1 1001 t1ss scale 1 1001 t100 swizzle -1 1010 d1xx convert +1 1010 d1xx 1 1011 00mm lea 1 1011 01ss any 1 1011 0100 lea_e @@ -32,7 +33,7 @@ bitmap_txt = """ 1 1011 1100 popregs 1 1101 01oo move 1 1101 11oo memset -1 1110 d1xx convert2 +1 1110 d1xx 1 11dd t100 vecops2 1 1100 ooss boolops n 1111 nnnn @@ -176,31 +177,13 @@ compare2_formats = { }, } convert_formats = { - "opcode": "OP_CONV_{op_conv[d*4+xx]}", - "mnemonic": "conv.{op_conv[d*4+xx]}", + "opcode": "OP_CONV", + "mnemonic": "conv", "opname": "conv", - "format": "%Ga %gc", + "format": "%Ga %Cb %gc", "widths": "1, 0, 1", - "types": "{cnv_types[xx][d]}, ev_invalid, {cnv_types[xx][1-d]}", - "args": { - "op_conv": ["IF", "LD", "uF", "UD", "FI", "DL", "Fu", "DU"], - "cnv_types": [ - ["ev_integer", "ev_float"], - ["ev_long", "ev_double"], - ["ev_uinteger", "ev_float"], - ["ev_ulong", "ev_double"], - ], - }, + "types": "ev_void, ev_short, ev_void", } -convert2_formats = copy.deepcopy (convert_formats) -convert2_formats["args"]["op_conv"] = [None, "IL", "uU", "FD", - None, "LI", "Uu", "DF"] -convert2_formats["args"]["cnv_types"] = [ - [None, None], - ["ev_integer", "ev_long"], - ["ev_uinteger", "ev_ulong"], - ["ev_float", "ev_double"], -] lea_formats = { "opcode": "OP_LEA_{op_mode[mm]}", "mnemonic": "lea", @@ -494,7 +477,6 @@ group_map = { "compare": compare_formats, "compare2": compare2_formats, "convert": convert_formats, - "convert2": convert2_formats, "lea": lea_formats, "lea_e": lea_e_formats, "load": load_formats, From e7d7ec19893e6bc928b106d0e0cede9df800da40 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 11 Jan 2022 09:37:38 +0900 Subject: [PATCH 085/360] [gamecode] Add tests for signed comparison ops Fortunately, they all pass without issues. --- libs/gamecode/test/test-double.c | 141 +++++++++++++++++++++++++++++++ libs/gamecode/test/test-float.c | 141 +++++++++++++++++++++++++++++++ libs/gamecode/test/test-int.c | 138 ++++++++++++++++++++++++++++++ libs/gamecode/test/test-long.c | 138 ++++++++++++++++++++++++++++++ 4 files changed, 558 insertions(+) diff --git a/libs/gamecode/test/test-double.c b/libs/gamecode/test/test-double.c index 8e11359ee..317e18df4 100644 --- a/libs/gamecode/test/test-double.c +++ b/libs/gamecode/test/test-double.c @@ -132,6 +132,102 @@ static dstatement_t double_cossin_statements[] = { { OP(0, 0, 0, OP_IFNZ_A), -7, 0, 46 }, // f0 < fmax }; +static pr_dvec4_t double_cmpop_init[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +// 5.0 as 64-bit int +#define F 0x4014000000000000l +#define mF 0xc014000000000000l +static pr_lvec4_t double_cmpop_expect[] = { + { F, mF, F, mF}, + { F, F, mF, mF}, + { -1, 0, 0, -1}, + { 0, -1, 0, 0}, + { 0, 0, -1, 0}, + { 0, -1, -1, 0}, + { -1, 0, -1, -1}, + { -1, -1, 0, -1}, +}; + +static dstatement_t double_cmpop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 64, -2, 64 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, + { OP(1, 1, 1, OP_EQ_D_1), 0, 8, 16 }, + { OP(1, 1, 1, OP_LT_D_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_GT_D_1), 0, 8, 32 }, + { OP(1, 1, 1, OP_NE_D_1), 0, 8, 40 }, + { OP(1, 1, 1, OP_GE_D_1), 0, 8, 48 }, + { OP(1, 1, 1, OP_LE_D_1), 0, 8, 56 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t double_cmpop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 64, -4, 64 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, + { OP(1, 1, 1, OP_EQ_D_2), 0, 8, 16 }, + { OP(1, 1, 1, OP_LT_D_2), 0, 8, 24 }, + { OP(1, 1, 1, OP_GT_D_2), 0, 8, 32 }, + { OP(1, 1, 1, OP_NE_D_2), 0, 8, 40 }, + { OP(1, 1, 1, OP_GE_D_2), 0, 8, 48 }, + { OP(1, 1, 1, OP_LE_D_2), 0, 8, 56 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t double_cmpop_3a_statements[] = { + { OP(1, 1, 1, OP_EQ_D_3), 0, 8, 16 }, + { OP(1, 1, 1, OP_EQ_D_1), 6, 14, 22 }, + { OP(1, 1, 1, OP_LT_D_3), 0, 8, 24 }, + { OP(1, 1, 1, OP_LT_D_1), 6, 14, 30 }, + { OP(1, 1, 1, OP_GT_D_3), 0, 8, 32 }, + { OP(1, 1, 1, OP_GT_D_1), 6, 14, 38 }, + { OP(1, 1, 1, OP_NE_D_3), 0, 8, 40 }, + { OP(1, 1, 1, OP_NE_D_1), 6, 14, 46 }, + { OP(1, 1, 1, OP_GE_D_3), 0, 8, 48 }, + { OP(1, 1, 1, OP_GE_D_1), 6, 14, 54 }, + { OP(1, 1, 1, OP_LE_D_3), 0, 8, 56 }, + { OP(1, 1, 1, OP_LE_D_1), 6, 14, 62 }, +}; + +static dstatement_t double_cmpop_3b_statements[] = { + { OP(1, 1, 1, OP_EQ_D_1), 0, 8, 16 }, + { OP(1, 1, 1, OP_EQ_D_3), 2, 10, 18 }, + { OP(1, 1, 1, OP_LT_D_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_LT_D_3), 2, 10, 26 }, + { OP(1, 1, 1, OP_GT_D_1), 0, 8, 32 }, + { OP(1, 1, 1, OP_GT_D_3), 2, 10, 34 }, + { OP(1, 1, 1, OP_NE_D_1), 0, 8, 40 }, + { OP(1, 1, 1, OP_NE_D_3), 2, 10, 42 }, + { OP(1, 1, 1, OP_GE_D_1), 0, 8, 48 }, + { OP(1, 1, 1, OP_GE_D_3), 2, 10, 50 }, + { OP(1, 1, 1, OP_LE_D_1), 0, 8, 56 }, + { OP(1, 1, 1, OP_LE_D_3), 2, 10, 58 }, +}; + +static dstatement_t double_cmpop_4_statements[] = { + { OP(1, 1, 1, OP_EQ_D_4), 0, 8, 16 }, + { OP(1, 1, 1, OP_LT_D_4), 0, 8, 24 }, + { OP(1, 1, 1, OP_GT_D_4), 0, 8, 32 }, + { OP(1, 1, 1, OP_NE_D_4), 0, 8, 40 }, + { OP(1, 1, 1, OP_GE_D_4), 0, 8, 48 }, + { OP(1, 1, 1, OP_LE_D_4), 0, 8, 56 }, +}; + test_t tests[] = { { .desc = "double binop 1", @@ -187,6 +283,51 @@ test_t tests[] = { .init_globals = (pr_int_t *) double_cossin_init, .expect_globals = (pr_int_t *) double_cossin_expect, }, + { + .desc = "double cmpop 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(double_cmpop_init,double_cmpop_expect), + .num_statements = num_statements (double_cmpop_1_statements), + .statements = double_cmpop_1_statements, + .init_globals = (pr_int_t *) double_cmpop_init, + .expect_globals = (pr_int_t *) double_cmpop_expect, + }, + { + .desc = "double cmpop 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(double_cmpop_init,double_cmpop_expect), + .num_statements = num_statements (double_cmpop_2_statements), + .statements = double_cmpop_2_statements, + .init_globals = (pr_int_t *) double_cmpop_init, + .expect_globals = (pr_int_t *) double_cmpop_expect, + }, + { + .desc = "double cmpop 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(double_cmpop_init,double_cmpop_expect), + .num_statements = num_statements (double_cmpop_3a_statements), + .statements = double_cmpop_3a_statements, + .init_globals = (pr_int_t *) double_cmpop_init, + .expect_globals = (pr_int_t *) double_cmpop_expect, + }, + { + .desc = "double cmpop 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(double_cmpop_init,double_cmpop_expect), + .num_statements = num_statements (double_cmpop_3b_statements), + .statements = double_cmpop_3b_statements, + .init_globals = (pr_int_t *) double_cmpop_init, + .expect_globals = (pr_int_t *) double_cmpop_expect, + }, + { + .desc = "double cmpop 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(double_cmpop_init,double_cmpop_expect), + .num_statements = num_statements (double_cmpop_4_statements), + .statements = double_cmpop_4_statements, + .init_globals = (pr_int_t *) double_cmpop_init, + .expect_globals = (pr_int_t *) double_cmpop_expect, + }, }; #include "main.c" diff --git a/libs/gamecode/test/test-float.c b/libs/gamecode/test/test-float.c index 8f5794c3d..d01e90518 100644 --- a/libs/gamecode/test/test-float.c +++ b/libs/gamecode/test/test-float.c @@ -132,6 +132,102 @@ static dstatement_t float_cossin_statements[] = { { OP(0, 0, 0, OP_IFNZ_A), -7, 0, 23 }, // f0 < fmax }; +static pr_vec4_t float_cmpop_init[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +// 5.0 as 32-bit int +#define F 0x40a00000 +#define mF 0xc0a00000 +static pr_ivec4_t float_cmpop_expect[] = { + { F, mF, F, mF}, + { F, F, mF, mF}, + { -1, 0, 0, -1}, + { 0, -1, 0, 0}, + { 0, 0, -1, 0}, + { 0, -1, -1, 0}, + { -1, 0, -1, -1}, + { -1, -1, 0, -1}, +}; + +static dstatement_t float_cmpop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 32, -1, 32 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, + { OP(1, 1, 1, OP_EQ_F_1), 0, 4, 8 }, + { OP(1, 1, 1, OP_LT_F_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_GT_F_1), 0, 4, 16 }, + { OP(1, 1, 1, OP_NE_F_1), 0, 4, 20 }, + { OP(1, 1, 1, OP_GE_F_1), 0, 4, 24 }, + { OP(1, 1, 1, OP_LE_F_1), 0, 4, 28 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t float_cmpop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // index +//loop: + { OP(0, 0, 0, OP_LEA_C), 32, -2, 32 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, + { OP(1, 1, 1, OP_EQ_F_2), 0, 4, 8 }, + { OP(1, 1, 1, OP_LT_F_2), 0, 4, 12 }, + { OP(1, 1, 1, OP_GT_F_2), 0, 4, 16 }, + { OP(1, 1, 1, OP_NE_F_2), 0, 4, 20 }, + { OP(1, 1, 1, OP_GE_F_2), 0, 4, 24 }, + { OP(1, 1, 1, OP_LE_F_2), 0, 4, 28 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t float_cmpop_3a_statements[] = { + { OP(1, 1, 1, OP_EQ_F_3), 0, 4, 8 }, + { OP(1, 1, 1, OP_EQ_F_1), 3, 7, 11 }, + { OP(1, 1, 1, OP_LT_F_3), 0, 4, 12 }, + { OP(1, 1, 1, OP_LT_F_1), 3, 7, 15 }, + { OP(1, 1, 1, OP_GT_F_3), 0, 4, 16 }, + { OP(1, 1, 1, OP_GT_F_1), 3, 7, 19 }, + { OP(1, 1, 1, OP_NE_F_3), 0, 4, 20 }, + { OP(1, 1, 1, OP_NE_F_1), 3, 7, 23 }, + { OP(1, 1, 1, OP_GE_F_3), 0, 4, 24 }, + { OP(1, 1, 1, OP_GE_F_1), 3, 7, 27 }, + { OP(1, 1, 1, OP_LE_F_3), 0, 4, 28 }, + { OP(1, 1, 1, OP_LE_F_1), 3, 7, 31 }, +}; + +static dstatement_t float_cmpop_3b_statements[] = { + { OP(1, 1, 1, OP_EQ_F_1), 0, 4, 8 }, + { OP(1, 1, 1, OP_EQ_F_3), 1, 5, 9 }, + { OP(1, 1, 1, OP_LT_F_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_LT_F_3), 1, 5, 13 }, + { OP(1, 1, 1, OP_GT_F_1), 0, 4, 16 }, + { OP(1, 1, 1, OP_GT_F_3), 1, 5, 17 }, + { OP(1, 1, 1, OP_NE_F_1), 0, 4, 20 }, + { OP(1, 1, 1, OP_NE_F_3), 1, 5, 21 }, + { OP(1, 1, 1, OP_GE_F_1), 0, 4, 24 }, + { OP(1, 1, 1, OP_GE_F_3), 1, 5, 25 }, + { OP(1, 1, 1, OP_LE_F_1), 0, 4, 28 }, + { OP(1, 1, 1, OP_LE_F_3), 1, 5, 29 }, +}; + +static dstatement_t float_cmpop_4_statements[] = { + { OP(1, 1, 1, OP_EQ_F_4), 0, 4, 8 }, + { OP(1, 1, 1, OP_LT_F_4), 0, 4, 12 }, + { OP(1, 1, 1, OP_GT_F_4), 0, 4, 16 }, + { OP(1, 1, 1, OP_NE_F_4), 0, 4, 20 }, + { OP(1, 1, 1, OP_GE_F_4), 0, 4, 24 }, + { OP(1, 1, 1, OP_LE_F_4), 0, 4, 28 }, +}; + test_t tests[] = { { .desc = "float binop 1", @@ -187,6 +283,51 @@ test_t tests[] = { .init_globals = (pr_int_t *) float_cossin_init, .expect_globals = (pr_int_t *) float_cossin_expect, }, + { + .desc = "float cmpop 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_cmpop_init,float_cmpop_expect), + .num_statements = num_statements (float_cmpop_1_statements), + .statements = float_cmpop_1_statements, + .init_globals = (pr_int_t *) float_cmpop_init, + .expect_globals = (pr_int_t *) float_cmpop_expect, + }, + { + .desc = "float cmpop 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_cmpop_init,float_cmpop_expect), + .num_statements = num_statements (float_cmpop_2_statements), + .statements = float_cmpop_2_statements, + .init_globals = (pr_int_t *) float_cmpop_init, + .expect_globals = (pr_int_t *) float_cmpop_expect, + }, + { + .desc = "float cmpop 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_cmpop_init,float_cmpop_expect), + .num_statements = num_statements (float_cmpop_3a_statements), + .statements = float_cmpop_3a_statements, + .init_globals = (pr_int_t *) float_cmpop_init, + .expect_globals = (pr_int_t *) float_cmpop_expect, + }, + { + .desc = "float cmpop 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_cmpop_init,float_cmpop_expect), + .num_statements = num_statements (float_cmpop_3b_statements), + .statements = float_cmpop_3b_statements, + .init_globals = (pr_int_t *) float_cmpop_init, + .expect_globals = (pr_int_t *) float_cmpop_expect, + }, + { + .desc = "float cmpop 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_cmpop_init,float_cmpop_expect), + .num_statements = num_statements (float_cmpop_4_statements), + .statements = float_cmpop_4_statements, + .init_globals = (pr_int_t *) float_cmpop_init, + .expect_globals = (pr_int_t *) float_cmpop_expect, + }, }; #include "main.c" diff --git a/libs/gamecode/test/test-int.c b/libs/gamecode/test/test-int.c index 08cfe3596..fd5d25af8 100644 --- a/libs/gamecode/test/test-int.c +++ b/libs/gamecode/test/test-int.c @@ -95,6 +95,99 @@ static dstatement_t int_binop_4_statements[] = { { OP(1, 1, 1, OP_SUB_I_4), 0, 4, 28 }, }; +static pr_ivec4_t int_cmpop_init[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_ivec4_t int_cmpop_expect[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + { -1, 0, 0, -1}, + { 0, -1, 0, 0}, + { 0, 0, -1, 0}, + { 0, -1, -1, 0}, + { -1, 0, -1, -1}, + { -1, -1, 0, -1}, +}; + +static dstatement_t int_cmpop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 32, -1, 32 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, + { OP(1, 1, 1, OP_EQ_I_1), 0, 4, 8 }, + { OP(1, 1, 1, OP_LT_I_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_GT_I_1), 0, 4, 16 }, + { OP(1, 1, 1, OP_NE_I_1), 0, 4, 20 }, + { OP(1, 1, 1, OP_GE_I_1), 0, 4, 24 }, + { OP(1, 1, 1, OP_LE_I_1), 0, 4, 28 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t int_cmpop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // index +//loop: + { OP(0, 0, 0, OP_LEA_C), 32, -2, 32 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, + { OP(1, 1, 1, OP_EQ_I_2), 0, 4, 8 }, + { OP(1, 1, 1, OP_LT_I_2), 0, 4, 12 }, + { OP(1, 1, 1, OP_GT_I_2), 0, 4, 16 }, + { OP(1, 1, 1, OP_NE_I_2), 0, 4, 20 }, + { OP(1, 1, 1, OP_GE_I_2), 0, 4, 24 }, + { OP(1, 1, 1, OP_LE_I_2), 0, 4, 28 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t int_cmpop_3a_statements[] = { + { OP(1, 1, 1, OP_EQ_I_3), 0, 4, 8 }, + { OP(1, 1, 1, OP_EQ_I_1), 3, 7, 11 }, + { OP(1, 1, 1, OP_LT_I_3), 0, 4, 12 }, + { OP(1, 1, 1, OP_LT_I_1), 3, 7, 15 }, + { OP(1, 1, 1, OP_GT_I_3), 0, 4, 16 }, + { OP(1, 1, 1, OP_GT_I_1), 3, 7, 19 }, + { OP(1, 1, 1, OP_NE_I_3), 0, 4, 20 }, + { OP(1, 1, 1, OP_NE_I_1), 3, 7, 23 }, + { OP(1, 1, 1, OP_GE_I_3), 0, 4, 24 }, + { OP(1, 1, 1, OP_GE_I_1), 3, 7, 27 }, + { OP(1, 1, 1, OP_LE_I_3), 0, 4, 28 }, + { OP(1, 1, 1, OP_LE_I_1), 3, 7, 31 }, +}; + +static dstatement_t int_cmpop_3b_statements[] = { + { OP(1, 1, 1, OP_EQ_I_1), 0, 4, 8 }, + { OP(1, 1, 1, OP_EQ_I_3), 1, 5, 9 }, + { OP(1, 1, 1, OP_LT_I_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_LT_I_3), 1, 5, 13 }, + { OP(1, 1, 1, OP_GT_I_1), 0, 4, 16 }, + { OP(1, 1, 1, OP_GT_I_3), 1, 5, 17 }, + { OP(1, 1, 1, OP_NE_I_1), 0, 4, 20 }, + { OP(1, 1, 1, OP_NE_I_3), 1, 5, 21 }, + { OP(1, 1, 1, OP_GE_I_1), 0, 4, 24 }, + { OP(1, 1, 1, OP_GE_I_3), 1, 5, 25 }, + { OP(1, 1, 1, OP_LE_I_1), 0, 4, 28 }, + { OP(1, 1, 1, OP_LE_I_3), 1, 5, 29 }, +}; + +static dstatement_t int_cmpop_4_statements[] = { + { OP(1, 1, 1, OP_EQ_I_4), 0, 4, 8 }, + { OP(1, 1, 1, OP_LT_I_4), 0, 4, 12 }, + { OP(1, 1, 1, OP_GT_I_4), 0, 4, 16 }, + { OP(1, 1, 1, OP_NE_I_4), 0, 4, 20 }, + { OP(1, 1, 1, OP_GE_I_4), 0, 4, 24 }, + { OP(1, 1, 1, OP_LE_I_4), 0, 4, 28 }, +}; + test_t tests[] = { { .desc = "int binop 1", @@ -141,6 +234,51 @@ test_t tests[] = { .init_globals = (pr_int_t *) int_binop_init, .expect_globals = (pr_int_t *) int_binop_expect, }, + { + .desc = "int cmpop 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_cmpop_init,int_cmpop_expect), + .num_statements = num_statements (int_cmpop_1_statements), + .statements = int_cmpop_1_statements, + .init_globals = (pr_int_t *) int_cmpop_init, + .expect_globals = (pr_int_t *) int_cmpop_expect, + }, + { + .desc = "int cmpop 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_cmpop_init,int_cmpop_expect), + .num_statements = num_statements (int_cmpop_2_statements), + .statements = int_cmpop_2_statements, + .init_globals = (pr_int_t *) int_cmpop_init, + .expect_globals = (pr_int_t *) int_cmpop_expect, + }, + { + .desc = "int cmpop 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_cmpop_init,int_cmpop_expect), + .num_statements = num_statements (int_cmpop_3a_statements), + .statements = int_cmpop_3a_statements, + .init_globals = (pr_int_t *) int_cmpop_init, + .expect_globals = (pr_int_t *) int_cmpop_expect, + }, + { + .desc = "int cmpop 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_cmpop_init,int_cmpop_expect), + .num_statements = num_statements (int_cmpop_3b_statements), + .statements = int_cmpop_3b_statements, + .init_globals = (pr_int_t *) int_cmpop_init, + .expect_globals = (pr_int_t *) int_cmpop_expect, + }, + { + .desc = "int cmpop 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_cmpop_init,int_cmpop_expect), + .num_statements = num_statements (int_cmpop_4_statements), + .statements = int_cmpop_4_statements, + .init_globals = (pr_int_t *) int_cmpop_init, + .expect_globals = (pr_int_t *) int_cmpop_expect, + }, }; #include "main.c" diff --git a/libs/gamecode/test/test-long.c b/libs/gamecode/test/test-long.c index 7777b38e0..fc1851151 100644 --- a/libs/gamecode/test/test-long.c +++ b/libs/gamecode/test/test-long.c @@ -97,6 +97,99 @@ static dstatement_t long_binop_4_statements[] = { { OP(1, 1, 1, OP_SUB_L_4), 0, 8, 56 }, }; +static pr_lvec4_t long_cmpop_init[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_lvec4_t long_cmpop_expect[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + { -1, 0, 0, -1}, + { 0, -1, 0, 0}, + { 0, 0, -1, 0}, + { 0, -1, -1, 0}, + { -1, 0, -1, -1}, + { -1, -1, 0, -1}, +}; + +static dstatement_t long_cmpop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 64, -2, 64 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, + { OP(1, 1, 1, OP_EQ_L_1), 0, 8, 16 }, + { OP(1, 1, 1, OP_LT_L_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_GT_L_1), 0, 8, 32 }, + { OP(1, 1, 1, OP_NE_L_1), 0, 8, 40 }, + { OP(1, 1, 1, OP_GE_L_1), 0, 8, 48 }, + { OP(1, 1, 1, OP_LE_L_1), 0, 8, 56 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t long_cmpop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 64, -4, 64 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, + { OP(1, 1, 1, OP_EQ_L_2), 0, 8, 16 }, + { OP(1, 1, 1, OP_LT_L_2), 0, 8, 24 }, + { OP(1, 1, 1, OP_GT_L_2), 0, 8, 32 }, + { OP(1, 1, 1, OP_NE_L_2), 0, 8, 40 }, + { OP(1, 1, 1, OP_GE_L_2), 0, 8, 48 }, + { OP(1, 1, 1, OP_LE_L_2), 0, 8, 56 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t long_cmpop_3a_statements[] = { + { OP(1, 1, 1, OP_EQ_L_3), 0, 8, 16 }, + { OP(1, 1, 1, OP_EQ_L_1), 6, 14, 22 }, + { OP(1, 1, 1, OP_LT_L_3), 0, 8, 24 }, + { OP(1, 1, 1, OP_LT_L_1), 6, 14, 30 }, + { OP(1, 1, 1, OP_GT_L_3), 0, 8, 32 }, + { OP(1, 1, 1, OP_GT_L_1), 6, 14, 38 }, + { OP(1, 1, 1, OP_NE_L_3), 0, 8, 40 }, + { OP(1, 1, 1, OP_NE_L_1), 6, 14, 46 }, + { OP(1, 1, 1, OP_GE_L_3), 0, 8, 48 }, + { OP(1, 1, 1, OP_GE_L_1), 6, 14, 54 }, + { OP(1, 1, 1, OP_LE_L_3), 0, 8, 56 }, + { OP(1, 1, 1, OP_LE_L_1), 6, 14, 62 }, +}; + +static dstatement_t long_cmpop_3b_statements[] = { + { OP(1, 1, 1, OP_EQ_L_1), 0, 8, 16 }, + { OP(1, 1, 1, OP_EQ_L_3), 2, 10, 18 }, + { OP(1, 1, 1, OP_LT_L_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_LT_L_3), 2, 10, 26 }, + { OP(1, 1, 1, OP_GT_L_1), 0, 8, 32 }, + { OP(1, 1, 1, OP_GT_L_3), 2, 10, 34 }, + { OP(1, 1, 1, OP_NE_L_1), 0, 8, 40 }, + { OP(1, 1, 1, OP_NE_L_3), 2, 10, 42 }, + { OP(1, 1, 1, OP_GE_L_1), 0, 8, 48 }, + { OP(1, 1, 1, OP_GE_L_3), 2, 10, 50 }, + { OP(1, 1, 1, OP_LE_L_1), 0, 8, 56 }, + { OP(1, 1, 1, OP_LE_L_3), 2, 10, 58 }, +}; + +static dstatement_t long_cmpop_4_statements[] = { + { OP(1, 1, 1, OP_EQ_L_4), 0, 8, 16 }, + { OP(1, 1, 1, OP_LT_L_4), 0, 8, 24 }, + { OP(1, 1, 1, OP_GT_L_4), 0, 8, 32 }, + { OP(1, 1, 1, OP_NE_L_4), 0, 8, 40 }, + { OP(1, 1, 1, OP_GE_L_4), 0, 8, 48 }, + { OP(1, 1, 1, OP_LE_L_4), 0, 8, 56 }, +}; + test_t tests[] = { { .desc = "long binop 1", @@ -143,6 +236,51 @@ test_t tests[] = { .init_globals = (pr_int_t *) long_binop_init, .expect_globals = (pr_int_t *) long_binop_expect, }, + { + .desc = "long cmpop 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(long_cmpop_init,long_cmpop_expect), + .num_statements = num_statements (long_cmpop_1_statements), + .statements = long_cmpop_1_statements, + .init_globals = (pr_int_t *) long_cmpop_init, + .expect_globals = (pr_int_t *) long_cmpop_expect, + }, + { + .desc = "long cmpop 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(long_cmpop_init,long_cmpop_expect), + .num_statements = num_statements (long_cmpop_2_statements), + .statements = long_cmpop_2_statements, + .init_globals = (pr_int_t *) long_cmpop_init, + .expect_globals = (pr_int_t *) long_cmpop_expect, + }, + { + .desc = "long cmpop 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(long_cmpop_init,long_cmpop_expect), + .num_statements = num_statements (long_cmpop_3a_statements), + .statements = long_cmpop_3a_statements, + .init_globals = (pr_int_t *) long_cmpop_init, + .expect_globals = (pr_int_t *) long_cmpop_expect, + }, + { + .desc = "long cmpop 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(long_cmpop_init,long_cmpop_expect), + .num_statements = num_statements (long_cmpop_3b_statements), + .statements = long_cmpop_3b_statements, + .init_globals = (pr_int_t *) long_cmpop_init, + .expect_globals = (pr_int_t *) long_cmpop_expect, + }, + { + .desc = "long cmpop 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(long_cmpop_init,long_cmpop_expect), + .num_statements = num_statements (long_cmpop_4_statements), + .statements = long_cmpop_4_statements, + .init_globals = (pr_int_t *) long_cmpop_init, + .expect_globals = (pr_int_t *) long_cmpop_expect, + }, }; #include "main.c" From 6229ae8ecc20c387a8214332dfd88a9f463c8e16 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 11 Jan 2022 13:00:54 +0900 Subject: [PATCH 086/360] [gamecode] Add tests for unsigned comparisons And fix the implementation: I had used the wrong macro. --- libs/gamecode/pr_exec.c | 17 +- libs/gamecode/test/Makemodule.am | 10 +- libs/gamecode/test/test-unsigned.c | 284 +++++++++++++++++++++++++++++ 3 files changed, 300 insertions(+), 11 deletions(-) create mode 100644 libs/gamecode/test/test-unsigned.c diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 66b1f3818..852f8f980 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -3121,7 +3121,6 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) // 0 1010 OP_cmp(GT, >); // 0 1011 - //FIXME conversion 1 // 0 1100 OP_cmp(NE, !=); // 0 1101 @@ -3300,20 +3299,20 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OP_op_T (BITXOR, I, int, ivec2, ivec4, ^); OP_uop_T (BITNOT, I, int, ivec2, ivec4, ~); // 1 1001 - OP_op_T (LT, u, uint, uivec2, uivec4, <); + OP_cmp_T (LT, u, int, ivec2, ivec4, <, uint, uivec2, uivec4); case OP_SWIZZLE_F: OPC(ivec4) = pr_swizzle_f (OPA(ivec4), st->b); break; //FIXME scale ops - OP_op_T (LT, U, ulong, ulvec2, ulvec4, <); + OP_cmp_T (LT, U, long, lvec2, lvec4, <, ulong, ulvec2, ulvec4); case OP_SWIZZLE_D: OPC(lvec4) = pr_swizzle_d (OPA(lvec4), st->b); break; //FIXME scale ops // 1 1010 - OP_op_T (GT, u, uint, uivec2, uivec4, >); + OP_cmp_T (GT, u, int, ivec2, ivec4, >, uint, uivec2, uivec4); //FIXME conversion ops - OP_op_T (GT, U, ulong, ulvec2, ulvec4, >); + OP_cmp_T (GT, U, long, lvec2, lvec4, >, ulong, ulvec2, ulvec4); //FIXME conversion ops // 1 1011 case OP_LEA_A: @@ -3415,7 +3414,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OP_not_3 (NOT, int, 3, +); OP_not_n (NOT, ivec4, 4, +); // 1 1101 - OP_op_T (GE, u, uint, uivec2, uivec4, >=); + OP_cmp_T (GE, u, int, ivec2, ivec4, >=, uint, uivec2, uivec4); case OP_QV4MUL_F: OPC(vec4) = qvmulf (OPA(vec4), OPB(vec4)); break; @@ -3430,7 +3429,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) memmove (pr->pr_globals + OPC(int), pr->pr_globals + OPA(int), st->b * sizeof (pr_type_t)); break; - OP_op_T (GE, U, ulong, ulvec2, ulvec4, >=); + OP_cmp_T (GE, U, long, lvec2, lvec4, >=, ulong, ulvec2, ulvec4); case OP_QV4MUL_D: OPC(dvec4) = qvmuld (OPA(dvec4), OPB(dvec4)); break; @@ -3444,12 +3443,12 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) pr_memset (pr->pr_globals + OPC(int), OPA(int), st->b); break; // 1 1110 - OP_op_T (LE, u, uint, uivec2, uivec4, <=); + OP_cmp_T (LE, u, int, ivec2, ivec4, <=, uint, uivec2, uivec4); case OP_V4QMUL_F: OPC(vec4) = vqmulf (OPA(vec4), OPB(vec4)); break; - OP_op_T (LE, U, ulong, ulvec2, ulvec4, <=); + OP_cmp_T (LE, U, long, lvec2, lvec4, <=, ulong, ulvec2, ulvec4); case OP_V4QMUL_D: OPC(dvec4) = vqmuld (OPA(dvec4), OPB(dvec4)); break; diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index 2df9ef114..af16fe67f 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -4,9 +4,10 @@ libs_gamecode_tests = \ libs/gamecode/test/test-int \ libs/gamecode/test/test-load \ libs/gamecode/test/test-long \ - libs/gamecode/test/test-vector \ libs/gamecode/test/test-stack \ - libs/gamecode/test/test-store + libs/gamecode/test/test-store \ + libs/gamecode/test/test-unsigned \ + libs/gamecode/test/test-vector TESTS += $(libs_gamecode_tests) @@ -57,3 +58,8 @@ libs_gamecode_test_test_vector_SOURCES= \ libs/gamecode/test/test-vector.c libs_gamecode_test_test_vector_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_vector_DEPENDENCIES= $(test_gamecode_libs) + +libs_gamecode_test_test_unsigned_SOURCES= \ + libs/gamecode/test/test-unsigned.c +libs_gamecode_test_test_unsigned_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_unsigned_DEPENDENCIES= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-unsigned.c b/libs/gamecode/test/test-unsigned.c new file mode 100644 index 000000000..ffd3959eb --- /dev/null +++ b/libs/gamecode/test/test-unsigned.c @@ -0,0 +1,284 @@ +#include "head.c" + +#include "QF/mathlib.h" + +static pr_uivec4_t uint_cmpop_init[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_uivec4_t uint_cmpop_expect[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + { 0, 0, 0, 0}, // no unsigned EQ (redundant) + { 0, 0, -1, 0}, + { 0, -1, 0, 0}, + { 0, 0, 0, 0}, // no unsigned NE (redundant) + { -1, -1, 0, -1}, + { -1, 0, -1, -1}, +}; + +static dstatement_t uint_cmpop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 32, -1, 32 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, + // no unsigned EQ (redundant) + { OP(1, 1, 1, OP_LT_u_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_GT_u_1), 0, 4, 16 }, + // no unsigned NE (redundant) + { OP(1, 1, 1, OP_GE_u_1), 0, 4, 24 }, + { OP(1, 1, 1, OP_LE_u_1), 0, 4, 28 }, + { OP(1, 1, 1, OP_JUMP_A), -8, 0, 0 }, +}; + +static dstatement_t uint_cmpop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // index +//loop: + { OP(0, 0, 0, OP_LEA_C), 32, -2, 32 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, + // no unsigned EQ (redundant) + { OP(1, 1, 1, OP_LT_u_2), 0, 4, 12 }, + { OP(1, 1, 1, OP_GT_u_2), 0, 4, 16 }, + // no unsigned NE (redundant) + { OP(1, 1, 1, OP_GE_u_2), 0, 4, 24 }, + { OP(1, 1, 1, OP_LE_u_2), 0, 4, 28 }, + { OP(1, 1, 1, OP_JUMP_A), -8, 0, 0 }, +}; + +static dstatement_t uint_cmpop_3a_statements[] = { + // no unsigned EQ (redundant) + // no unsigned EQ (redundant) + { OP(1, 1, 1, OP_LT_u_3), 0, 4, 12 }, + { OP(1, 1, 1, OP_LT_u_1), 3, 7, 15 }, + { OP(1, 1, 1, OP_GT_u_3), 0, 4, 16 }, + { OP(1, 1, 1, OP_GT_u_1), 3, 7, 19 }, + // no unsigned NE (redundant) + // no unsigned NE (redundant) + { OP(1, 1, 1, OP_GE_u_3), 0, 4, 24 }, + { OP(1, 1, 1, OP_GE_u_1), 3, 7, 27 }, + { OP(1, 1, 1, OP_LE_u_3), 0, 4, 28 }, + { OP(1, 1, 1, OP_LE_u_1), 3, 7, 31 }, +}; + +static dstatement_t uint_cmpop_3b_statements[] = { + // no unsigned EQ (redundant) + // no unsigned EQ (redundant) + { OP(1, 1, 1, OP_LT_u_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_LT_u_3), 1, 5, 13 }, + { OP(1, 1, 1, OP_GT_u_1), 0, 4, 16 }, + { OP(1, 1, 1, OP_GT_u_3), 1, 5, 17 }, + // no unsigned NE (redundant) + // no unsigned NE (redundant) + { OP(1, 1, 1, OP_GE_u_1), 0, 4, 24 }, + { OP(1, 1, 1, OP_GE_u_3), 1, 5, 25 }, + { OP(1, 1, 1, OP_LE_u_1), 0, 4, 28 }, + { OP(1, 1, 1, OP_LE_u_3), 1, 5, 29 }, +}; + +static dstatement_t uint_cmpop_4_statements[] = { + // no unsigned EQ (redundant) + { OP(1, 1, 1, OP_LT_u_4), 0, 4, 12 }, + { OP(1, 1, 1, OP_GT_u_4), 0, 4, 16 }, + // no unsigned NE (redundant) + { OP(1, 1, 1, OP_GE_u_4), 0, 4, 24 }, + { OP(1, 1, 1, OP_LE_u_4), 0, 4, 28 }, +}; + +static pr_ulvec4_t ulong_cmpop_init[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_ulvec4_t ulong_cmpop_expect[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + { 0, 0, 0, 0}, // no unsigned EQ (redundant) + { 0, 0, -1, 0}, + { 0, -1, 0, 0}, + { 0, 0, 0, 0}, // no unsigned NE (redundant) + { -1, -1, 0, -1}, + { -1, 0, -1, -1}, +}; + +static dstatement_t ulong_cmpop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 64, -2, 64 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, + // no unsigned EQ (redundant) + { OP(1, 1, 1, OP_LT_U_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_GT_U_1), 0, 8, 32 }, + // no unsigned NE (redundant) + { OP(1, 1, 1, OP_GE_U_1), 0, 8, 48 }, + { OP(1, 1, 1, OP_LE_U_1), 0, 8, 56 }, + { OP(1, 1, 1, OP_JUMP_A), -8, 0, 0 }, +}; + +static dstatement_t ulong_cmpop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 64, -4, 64 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, + // no unsigned EQ (redundant) + { OP(1, 1, 1, OP_LT_U_2), 0, 8, 24 }, + { OP(1, 1, 1, OP_GT_U_2), 0, 8, 32 }, + // no unsigned NE (redundant) + { OP(1, 1, 1, OP_GE_U_2), 0, 8, 48 }, + { OP(1, 1, 1, OP_LE_U_2), 0, 8, 56 }, + { OP(1, 1, 1, OP_JUMP_A), -8, 0, 0 }, +}; + +static dstatement_t ulong_cmpop_3a_statements[] = { + // no unsigned EQ (redundant) + // no unsigned EQ (redundant) + { OP(1, 1, 1, OP_LT_U_3), 0, 8, 24 }, + { OP(1, 1, 1, OP_LT_U_1), 6, 14, 30 }, + { OP(1, 1, 1, OP_GT_U_3), 0, 8, 32 }, + { OP(1, 1, 1, OP_GT_U_1), 6, 14, 38 }, + // no unsigned NE (redundant) + // no unsigned NE (redundant) + { OP(1, 1, 1, OP_GE_U_3), 0, 8, 48 }, + { OP(1, 1, 1, OP_GE_U_1), 6, 14, 54 }, + { OP(1, 1, 1, OP_LE_U_3), 0, 8, 56 }, + { OP(1, 1, 1, OP_LE_U_1), 6, 14, 62 }, +}; + +static dstatement_t ulong_cmpop_3b_statements[] = { + // no unsigned EQ (redundant) + // no unsigned EQ (redundant) + { OP(1, 1, 1, OP_LT_U_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_LT_U_3), 2, 10, 26 }, + { OP(1, 1, 1, OP_GT_U_1), 0, 8, 32 }, + { OP(1, 1, 1, OP_GT_U_3), 2, 10, 34 }, + // no unsigned NE (redundant) + // no unsigned NE (redundant) + { OP(1, 1, 1, OP_GE_U_1), 0, 8, 48 }, + { OP(1, 1, 1, OP_GE_U_3), 2, 10, 50 }, + { OP(1, 1, 1, OP_LE_U_1), 0, 8, 56 }, + { OP(1, 1, 1, OP_LE_U_3), 2, 10, 58 }, +}; + +static dstatement_t ulong_cmpop_4_statements[] = { + // no unsigned EQ (redundant) + { OP(1, 1, 1, OP_LT_U_4), 0, 8, 24 }, + { OP(1, 1, 1, OP_GT_U_4), 0, 8, 32 }, + // no unsigned NE (redundant) + { OP(1, 1, 1, OP_GE_U_4), 0, 8, 48 }, + { OP(1, 1, 1, OP_LE_U_4), 0, 8, 56 }, +}; + +test_t tests[] = { + { + .desc = "uint cmpop 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_cmpop_init,uint_cmpop_expect), + .num_statements = num_statements (uint_cmpop_1_statements), + .statements = uint_cmpop_1_statements, + .init_globals = (pr_int_t *) uint_cmpop_init, + .expect_globals = (pr_int_t *) uint_cmpop_expect, + }, + { + .desc = "uint cmpop 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_cmpop_init,uint_cmpop_expect), + .num_statements = num_statements (uint_cmpop_2_statements), + .statements = uint_cmpop_2_statements, + .init_globals = (pr_int_t *) uint_cmpop_init, + .expect_globals = (pr_int_t *) uint_cmpop_expect, + }, + { + .desc = "uint cmpop 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_cmpop_init,uint_cmpop_expect), + .num_statements = num_statements (uint_cmpop_3a_statements), + .statements = uint_cmpop_3a_statements, + .init_globals = (pr_int_t *) uint_cmpop_init, + .expect_globals = (pr_int_t *) uint_cmpop_expect, + }, + { + .desc = "uint cmpop 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_cmpop_init,uint_cmpop_expect), + .num_statements = num_statements (uint_cmpop_3b_statements), + .statements = uint_cmpop_3b_statements, + .init_globals = (pr_int_t *) uint_cmpop_init, + .expect_globals = (pr_int_t *) uint_cmpop_expect, + }, + { + .desc = "uint cmpop 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_cmpop_init,uint_cmpop_expect), + .num_statements = num_statements (uint_cmpop_4_statements), + .statements = uint_cmpop_4_statements, + .init_globals = (pr_int_t *) uint_cmpop_init, + .expect_globals = (pr_int_t *) uint_cmpop_expect, + }, + { + .desc = "ulong cmpop 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_cmpop_init,ulong_cmpop_expect), + .num_statements = num_statements (ulong_cmpop_1_statements), + .statements = ulong_cmpop_1_statements, + .init_globals = (pr_int_t *) ulong_cmpop_init, + .expect_globals = (pr_int_t *) ulong_cmpop_expect, + }, + { + .desc = "ulong cmpop 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_cmpop_init,ulong_cmpop_expect), + .num_statements = num_statements (ulong_cmpop_2_statements), + .statements = ulong_cmpop_2_statements, + .init_globals = (pr_int_t *) ulong_cmpop_init, + .expect_globals = (pr_int_t *) ulong_cmpop_expect, + }, + { + .desc = "ulong cmpop 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_cmpop_init,ulong_cmpop_expect), + .num_statements = num_statements (ulong_cmpop_3a_statements), + .statements = ulong_cmpop_3a_statements, + .init_globals = (pr_int_t *) ulong_cmpop_init, + .expect_globals = (pr_int_t *) ulong_cmpop_expect, + }, + { + .desc = "ulong cmpop 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_cmpop_init,ulong_cmpop_expect), + .num_statements = num_statements (ulong_cmpop_3b_statements), + .statements = ulong_cmpop_3b_statements, + .init_globals = (pr_int_t *) ulong_cmpop_init, + .expect_globals = (pr_int_t *) ulong_cmpop_expect, + }, + { + .desc = "ulong cmpop 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_cmpop_init,ulong_cmpop_expect), + .num_statements = num_statements (ulong_cmpop_4_statements), + .statements = ulong_cmpop_4_statements, + .init_globals = (pr_int_t *) ulong_cmpop_init, + .expect_globals = (pr_int_t *) ulong_cmpop_expect, + }, +}; + +#include "main.c" From f7181a09b439cb9f9acb20d87e4e9ef4d37e3c37 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 12 Jan 2022 10:24:59 +0900 Subject: [PATCH 087/360] [gamecode] Add tests for shiftops They're in test-unsigned because 2/3 of them are unsigned. --- libs/gamecode/test/test-unsigned.c | 288 +++++++++++++++++++++++++++++ 1 file changed, 288 insertions(+) diff --git a/libs/gamecode/test/test-unsigned.c b/libs/gamecode/test/test-unsigned.c index ffd3959eb..298ed5c26 100644 --- a/libs/gamecode/test/test-unsigned.c +++ b/libs/gamecode/test/test-unsigned.c @@ -188,6 +188,204 @@ static dstatement_t ulong_cmpop_4_statements[] = { { OP(1, 1, 1, OP_LE_U_4), 0, 8, 56 }, }; +static pr_uivec4_t uint_shiftop_init[] = { + { 0x12345678, 0x9abcdef0, 0x80000001, 0xaaaa5555 }, + { 12, 16, 9, 1 }, + { 20, 16, 23, 31 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, +}; + +static pr_uivec4_t uint_shiftop_expect[] = { + { 0x12345678, 0x9abcdef0, 0x80000001, 0xaaaa5555 }, + { 12, 16, 9, 1 },//a + { 20, 16, 23, 31 },//b + { 0x45678000, 0xdef00000, 0x00000200, 0x5554aaaa },//shl a + { 0x67800000, 0xdef00000, 0x00800000, 0x80000000 },//shl b + { 0x00012345, 0x00009abc, 0x00400000, 0x55552aaa },//shr a + { 0x00000123, 0x00009abc, 0x00000100, 0x00000001 },//shr b + { 0x00012345, 0xffff9abc, 0xffc00000, 0xd5552aaa },//asr a + { 0x00000123, 0xffff9abc, 0xffffff00, 0xffffffff },//asr b +}; + +static dstatement_t uint_shiftop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 36 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 36, -1, 36 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 36 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 36, 1 }, + { OP(1, 1, 1, OP_SHL_I_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_SHL_I_1), 0, 8, 16 }, + { OP(1, 1, 1, OP_SHR_u_1), 0, 4, 20 }, + { OP(1, 1, 1, OP_SHR_u_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_ASR_I_1), 0, 4, 28 }, + { OP(1, 1, 1, OP_ASR_I_1), 0, 8, 32 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t uint_shiftop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 36 }, // index +//loop: + { OP(0, 0, 0, OP_LEA_C), 36, -2, 36 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 36 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 36, 1 }, + { OP(1, 1, 1, OP_SHL_I_2), 0, 4, 12 }, + { OP(1, 1, 1, OP_SHL_I_2), 0, 8, 16 }, + { OP(1, 1, 1, OP_SHR_u_2), 0, 4, 20 }, + { OP(1, 1, 1, OP_SHR_u_2), 0, 8, 24 }, + { OP(1, 1, 1, OP_ASR_I_2), 0, 4, 28 }, + { OP(1, 1, 1, OP_ASR_I_2), 0, 8, 32 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t uint_shiftop_3a_statements[] = { + { OP(1, 1, 1, OP_SHL_I_3), 0, 4, 12 }, + { OP(1, 1, 1, OP_SHL_I_1), 3, 7, 15 }, + { OP(1, 1, 1, OP_SHL_I_3), 0, 8, 16 }, + { OP(1, 1, 1, OP_SHL_I_1), 3, 11, 19 }, + { OP(1, 1, 1, OP_SHR_u_3), 0, 4, 20 }, + { OP(1, 1, 1, OP_SHR_u_1), 3, 7, 23 }, + { OP(1, 1, 1, OP_SHR_u_3), 0, 8, 24 }, + { OP(1, 1, 1, OP_SHR_u_1), 3, 11, 27 }, + { OP(1, 1, 1, OP_ASR_I_3), 0, 4, 28 }, + { OP(1, 1, 1, OP_ASR_I_1), 3, 7, 31 }, + { OP(1, 1, 1, OP_ASR_I_3), 0, 8, 32 }, + { OP(1, 1, 1, OP_ASR_I_1), 3, 11, 35 }, +}; + +static dstatement_t uint_shiftop_3b_statements[] = { + { OP(1, 1, 1, OP_SHL_I_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_SHL_I_3), 1, 5, 13 }, + { OP(1, 1, 1, OP_SHL_I_1), 0, 8, 16 }, + { OP(1, 1, 1, OP_SHL_I_3), 1, 9, 17 }, + { OP(1, 1, 1, OP_SHR_u_1), 0, 4, 20 }, + { OP(1, 1, 1, OP_SHR_u_3), 1, 5, 21 }, + { OP(1, 1, 1, OP_SHR_u_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_SHR_u_3), 1, 9, 25 }, + { OP(1, 1, 1, OP_ASR_I_1), 0, 4, 28 }, + { OP(1, 1, 1, OP_ASR_I_3), 1, 5, 29 }, + { OP(1, 1, 1, OP_ASR_I_1), 0, 8, 32 }, + { OP(1, 1, 1, OP_ASR_I_3), 1, 9, 33 }, +}; + +static dstatement_t uint_shiftop_4_statements[] = { + { OP(1, 1, 1, OP_SHL_I_4), 0, 4, 12 }, + { OP(1, 1, 1, OP_SHL_I_4), 0, 8, 16 }, + { OP(1, 1, 1, OP_SHR_u_4), 0, 4, 20 }, + { OP(1, 1, 1, OP_SHR_u_4), 0, 8, 24 }, + { OP(1, 1, 1, OP_ASR_I_4), 0, 4, 28 }, + { OP(1, 1, 1, OP_ASR_I_4), 0, 8, 32 }, +}; + +static pr_ulvec4_t ulong_shiftop_init[] = { + { UINT64_C(0x123456789abcdef0), UINT64_C(0x9abcdef012345678), + UINT64_C(0x8000000180000001), UINT64_C(0xaaaa5555aaaa5555) }, + { 12, 16, 9, 1 }, + { 52, 48, 55, 63 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, +}; + +static pr_ulvec4_t ulong_shiftop_expect[] = { + { UINT64_C(0x123456789abcdef0), UINT64_C(0x9abcdef012345678), + UINT64_C(0x8000000180000001), UINT64_C(0xaaaa5555aaaa5555) }, + { 12, 16, 9, 1 },//a + { 52, 48, 55, 63 },//b + { UINT64_C(0x456789abcdef0000), UINT64_C(0xdef0123456780000), + UINT64_C(0x0000030000000200), UINT64_C(0x5554aaab5554aaaa) },//shl a + { UINT64_C(0xef00000000000000), UINT64_C(0x5678000000000000), + UINT64_C(0x0020000000000000), UINT64_C(0x8000000000000000) },//shl b + { UINT64_C(0x000123456789abcd), UINT64_C(0x00009abcdef01234), + UINT64_C(0x0040000000c00000), UINT64_C(0x55552aaad5552aaa) },//shr a + { UINT64_C(0x0000000000000123), UINT64_C(0x0000000000009abc), + UINT64_C(0x0000000000000100), UINT64_C(0x0000000000000001) },//shr b + { UINT64_C(0x000123456789abcd), UINT64_C(0xffff9abcdef01234), + UINT64_C(0xffc0000000c00000), UINT64_C(0xd5552aaad5552aaa) },//asr a + { UINT64_C(0x0000000000000123), UINT64_C(0xffffffffffff9abc), + UINT64_C(0xffffffffffffff00), UINT64_C(0xffffffffffffffff) },//asr b +}; + +static dstatement_t ulong_shiftop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 72 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 72, -2, 72 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 72 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 72, 1 }, + { OP(1, 1, 1, OP_SHL_L_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_SHL_L_1), 0, 16, 32 }, + { OP(1, 1, 1, OP_SHR_U_1), 0, 8, 40 }, + { OP(1, 1, 1, OP_SHR_U_1), 0, 16, 48 }, + { OP(1, 1, 1, OP_ASR_L_1), 0, 8, 56 }, + { OP(1, 1, 1, OP_ASR_L_1), 0, 16, 64 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t ulong_shiftop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 72 }, // index +//loop: + { OP(0, 0, 0, OP_LEA_C), 72, -4, 72 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 72 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 72, 1 }, + { OP(1, 1, 1, OP_SHL_L_2), 0, 8, 24 }, + { OP(1, 1, 1, OP_SHL_L_2), 0, 16, 32 }, + { OP(1, 1, 1, OP_SHR_U_2), 0, 8, 40 }, + { OP(1, 1, 1, OP_SHR_U_2), 0, 16, 48 }, + { OP(1, 1, 1, OP_ASR_L_2), 0, 8, 56 }, + { OP(1, 1, 1, OP_ASR_L_2), 0, 16, 64 }, + { OP(1, 1, 1, OP_JUMP_A), -10, 0, 0 }, +}; + +static dstatement_t ulong_shiftop_3a_statements[] = { + { OP(1, 1, 1, OP_SHL_L_3), 0, 8, 24 }, + { OP(1, 1, 1, OP_SHL_L_1), 6, 14, 30 }, + { OP(1, 1, 1, OP_SHL_L_3), 0, 16, 32 }, + { OP(1, 1, 1, OP_SHL_L_1), 6, 22, 38 }, + { OP(1, 1, 1, OP_SHR_U_3), 0, 8, 40 }, + { OP(1, 1, 1, OP_SHR_U_1), 6, 14, 46 }, + { OP(1, 1, 1, OP_SHR_U_3), 0, 16, 48 }, + { OP(1, 1, 1, OP_SHR_U_1), 6, 22, 54 }, + { OP(1, 1, 1, OP_ASR_L_3), 0, 8, 56 }, + { OP(1, 1, 1, OP_ASR_L_1), 6, 14, 62 }, + { OP(1, 1, 1, OP_ASR_L_3), 0, 16, 64 }, + { OP(1, 1, 1, OP_ASR_L_1), 6, 22, 70 }, +}; + +static dstatement_t ulong_shiftop_3b_statements[] = { + { OP(1, 1, 1, OP_SHL_L_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_SHL_L_3), 2, 10, 26 }, + { OP(1, 1, 1, OP_SHL_L_1), 0, 16, 32 }, + { OP(1, 1, 1, OP_SHL_L_3), 2, 18, 34 }, + { OP(1, 1, 1, OP_SHR_U_1), 0, 8, 40 }, + { OP(1, 1, 1, OP_SHR_U_3), 2, 10, 42 }, + { OP(1, 1, 1, OP_SHR_U_1), 0, 16, 48 }, + { OP(1, 1, 1, OP_SHR_U_3), 2, 18, 50 }, + { OP(1, 1, 1, OP_ASR_L_1), 0, 8, 56 }, + { OP(1, 1, 1, OP_ASR_L_3), 2, 10, 58 }, + { OP(1, 1, 1, OP_ASR_L_1), 0, 16, 64 }, + { OP(1, 1, 1, OP_ASR_L_3), 2, 18, 66 }, +}; + +static dstatement_t ulong_shiftop_4_statements[] = { + { OP(1, 1, 1, OP_SHL_L_4), 0, 8, 24 }, + { OP(1, 1, 1, OP_SHL_L_4), 0, 16, 32 }, + { OP(1, 1, 1, OP_SHR_U_4), 0, 8, 40 }, + { OP(1, 1, 1, OP_SHR_U_4), 0, 16, 48 }, + { OP(1, 1, 1, OP_ASR_L_4), 0, 8, 56 }, + { OP(1, 1, 1, OP_ASR_L_4), 0, 16, 64 }, +}; + test_t tests[] = { { .desc = "uint cmpop 1", @@ -279,6 +477,96 @@ test_t tests[] = { .init_globals = (pr_int_t *) ulong_cmpop_init, .expect_globals = (pr_int_t *) ulong_cmpop_expect, }, + { + .desc = "uint shiftop 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_shiftop_init,uint_shiftop_expect), + .num_statements = num_statements (uint_shiftop_1_statements), + .statements = uint_shiftop_1_statements, + .init_globals = (pr_int_t *) uint_shiftop_init, + .expect_globals = (pr_int_t *) uint_shiftop_expect, + }, + { + .desc = "uint shiftop 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_shiftop_init,uint_shiftop_expect), + .num_statements = num_statements (uint_shiftop_2_statements), + .statements = uint_shiftop_2_statements, + .init_globals = (pr_int_t *) uint_shiftop_init, + .expect_globals = (pr_int_t *) uint_shiftop_expect, + }, + { + .desc = "uint shiftop 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_shiftop_init,uint_shiftop_expect), + .num_statements = num_statements (uint_shiftop_3a_statements), + .statements = uint_shiftop_3a_statements, + .init_globals = (pr_int_t *) uint_shiftop_init, + .expect_globals = (pr_int_t *) uint_shiftop_expect, + }, + { + .desc = "uint shiftop 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_shiftop_init,uint_shiftop_expect), + .num_statements = num_statements (uint_shiftop_3b_statements), + .statements = uint_shiftop_3b_statements, + .init_globals = (pr_int_t *) uint_shiftop_init, + .expect_globals = (pr_int_t *) uint_shiftop_expect, + }, + { + .desc = "uint shiftop 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_shiftop_init,uint_shiftop_expect), + .num_statements = num_statements (uint_shiftop_4_statements), + .statements = uint_shiftop_4_statements, + .init_globals = (pr_int_t *) uint_shiftop_init, + .expect_globals = (pr_int_t *) uint_shiftop_expect, + }, + { + .desc = "ulong shiftop 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_shiftop_init,ulong_shiftop_expect), + .num_statements = num_statements (ulong_shiftop_1_statements), + .statements = ulong_shiftop_1_statements, + .init_globals = (pr_int_t *) ulong_shiftop_init, + .expect_globals = (pr_int_t *) ulong_shiftop_expect, + }, + { + .desc = "ulong shiftop 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_shiftop_init,ulong_shiftop_expect), + .num_statements = num_statements (ulong_shiftop_2_statements), + .statements = ulong_shiftop_2_statements, + .init_globals = (pr_int_t *) ulong_shiftop_init, + .expect_globals = (pr_int_t *) ulong_shiftop_expect, + }, + { + .desc = "ulong shiftop 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_shiftop_init,ulong_shiftop_expect), + .num_statements = num_statements (ulong_shiftop_3a_statements), + .statements = ulong_shiftop_3a_statements, + .init_globals = (pr_int_t *) ulong_shiftop_init, + .expect_globals = (pr_int_t *) ulong_shiftop_expect, + }, + { + .desc = "ulong shiftop 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_shiftop_init,ulong_shiftop_expect), + .num_statements = num_statements (ulong_shiftop_3b_statements), + .statements = ulong_shiftop_3b_statements, + .init_globals = (pr_int_t *) ulong_shiftop_init, + .expect_globals = (pr_int_t *) ulong_shiftop_expect, + }, + { + .desc = "ulong shiftop 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_shiftop_init,ulong_shiftop_expect), + .num_statements = num_statements (ulong_shiftop_4_statements), + .statements = ulong_shiftop_4_statements, + .init_globals = (pr_int_t *) ulong_shiftop_init, + .expect_globals = (pr_int_t *) ulong_shiftop_expect, + }, }; #include "main.c" From 3587b13a4037694166025a81c66dec7122a5fe56 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 10 Jan 2022 17:01:14 +0900 Subject: [PATCH 088/360] [gamecode] Implement the conversion instructions Not all possibilities are supported because converting between int and uint, and long and ulong is essentially a no-op. However, thanks to Deek's suggestion, not only are all reasonable conversions available, conversions for all widths are available, so vector conversions are supported. The code for the conversions is generated. --- libs/gamecode/Makemodule.am | 9 ++++- libs/gamecode/convert.py | 66 +++++++++++++++++++++++++++++++++++++ libs/gamecode/pr_exec.c | 32 +++++++++++------- 3 files changed, 95 insertions(+), 12 deletions(-) create mode 100644 libs/gamecode/convert.py diff --git a/libs/gamecode/Makemodule.am b/libs/gamecode/Makemodule.am index e3c9b5441..ea9ae11b1 100644 --- a/libs/gamecode/Makemodule.am +++ b/libs/gamecode/Makemodule.am @@ -31,7 +31,10 @@ pr_opcode_src = \ ${pr_opcode_hinc} libs/gamecode/pr_opcode.lo: libs/gamecode/pr_opcode.c ${pr_opcode_src} -BUILT_SOURCES += $(pr_opcode_cinc) $(pr_opcode_hinc) +convert_py = $(srcdir)/libs/gamecode/convert.py +pr_convert_cinc = $(top_builddir)/libs/gamecode/pr_convert.cinc + +BUILT_SOURCES += $(pr_opcode_cinc) $(pr_opcode_hinc) $(pr_convert_cinc) $(pr_opcode_cinc): $(opcodes_py) $(V_PY)$(PYTHON) $(opcodes_py) table > $(pr_opcode_cinc).t && \ @@ -41,3 +44,7 @@ $(pr_opcode_hinc): $(opcodes_py) $(V_PY) mkdir -p `dirname $(pr_opcode_hinc)` &&\ $(PYTHON) $(opcodes_py) enum > $(pr_opcode_hinc).t && \ $(am__mv) $(pr_opcode_hinc).t $(pr_opcode_hinc) + +$(pr_convert_cinc): $(convert_py) + $(V_PY)$(PYTHON) $(convert_py) table > $(pr_convert_cinc).t && \ + $(am__mv) $(pr_convert_cinc).t $(pr_convert_cinc) diff --git a/libs/gamecode/convert.py b/libs/gamecode/convert.py new file mode 100644 index 000000000..380a5526e --- /dev/null +++ b/libs/gamecode/convert.py @@ -0,0 +1,66 @@ +print("""// types are encoded as ubf where: +// u = 0: signed, u = 1: unsigned +// b = 0: 32-bit, b = 1: 64-bit +// f = 0: int, f = 1: float/double +// width is ww where: +// ww = 00: 1 component +// ww = 01: 2 components +// ww = 10: 3 components +// ww = 11: 4 components +// full conversion code is wwsssddd where: +// ww = width +// sss = src type +// ddd = dst type +// case values are in octal +""") +types = [ + "int", + "float", + "long", + "double", + "uint", + None, # no such thing as unsigned float + "ulong", + None, # no such thing as unsigned double +] +#does not include size (2 or 4, 3 is special) +vec_types = [ + "ivec", + "vec", + "lvec", + "dvec", + "uivec", + None, # no such thing as unsigned float + "ulvec", + None, # no such thing as unsigned double +] +skip_matrix = [ + #i f l d ui X ul X + [1, 0, 0, 0, 1, 1, 0, 1], # i + [0, 1, 0, 0, 0, 1, 0, 1], # f + [0, 0, 1, 0, 0, 1, 1, 1], # l + [0, 0, 0, 1, 0, 1, 0, 1], # d + + [1, 0, 0, 0, 1, 1, 0, 1], # ui + [1, 1, 1, 1, 1, 1, 1, 1], # X + [0, 0, 1, 0, 0, 1, 1, 1], # ul + [1, 1, 1, 1, 1, 1, 1, 1], # X +] +for width in range(4): + for src_type in range(8): + for dst_type in range(8): + if skip_matrix[src_type][dst_type]: + continue + case = (width << 6) | (src_type << 3) | (dst_type) + if width == 0: + print(f"case {case:04o}: OPC({types[dst_type]}) = (pr_{types[dst_type]}_t) OPA({types[src_type]}); break;") + elif width == 2: + print(f"case {case:04o}: VectorCompUop(&OPC({types[dst_type]}), (pr_{types[dst_type]}_t), &OPA({types[src_type]})); break;") + else: + if (src_type & 2) == (dst_type & 2): + print(f"case {case:04o}: OPC({vec_types[dst_type]}{width+1}) = (pr_{vec_types[dst_type]}{width+1}_t) OPA({vec_types[src_type]}{width+1}); break;") + else: + print(f"case {case:04o}:") + for i in range(width + 1): + print(f"\t(&OPC({types[dst_type]}))[{i}] = (pr_{types[dst_type]}_t) (&OPA({types[src_type]}))[{i}];") + print(f"\tbreak;") diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 852f8f980..684205b80 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -2915,6 +2915,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) pr->pr_xstatement = pr_jump_mode (pr, st); st = pr->pr_statements + pr->pr_xstatement; break; + // 0 0101 case OP_IFNZ_A: case OP_IFNZ_B: case OP_IFNZ_C: @@ -2972,9 +2973,17 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) PR_CallFunction (pr, function); st = pr->pr_statements + pr->pr_xstatement; break; - // 0 0101 - // nnn spare - //OP_CONV + // 0 0110 + // 0nnn spare + // 10nn spare + case OP_CONV: + switch (st->b) { +#include "libs/gamecode/pr_convert.cinc" + default: + PR_RunError (pr, "invalid conversion code: %04o", + st->b); + } + break; case OP_WITH: pr->pr_bases[st->c & 3] = pr_with (pr, st); break; @@ -3002,7 +3011,6 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) pr->pr_edict_area[think].func_var = op_b->func_var; } break; - // 0 0110 // 0 0111 case OP_CROSS_F: { @@ -3121,14 +3129,16 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) // 0 1010 OP_cmp(GT, >); // 0 1011 + // spare // 0 1100 OP_cmp(NE, !=); // 0 1101 OP_cmp(GE, >=); // 0 1110 OP_cmp(LE, <=); - // 0 1011 - //FIXME conversion 2 + + // 0 1111 + // spare #define OP_op_1(OP, T, t, op) \ case OP_##OP##_##T##_1: \ @@ -3311,9 +3321,9 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) //FIXME scale ops // 1 1010 OP_cmp_T (GT, u, int, ivec2, ivec4, >, uint, uivec2, uivec4); - //FIXME conversion ops + // spare OP_cmp_T (GT, U, long, lvec2, lvec4, >, ulong, ulvec2, ulvec4); - //FIXME conversion ops + // spare // 1 1011 case OP_LEA_A: case OP_LEA_B: @@ -3447,14 +3457,14 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_V4QMUL_F: OPC(vec4) = vqmulf (OPA(vec4), OPB(vec4)); break; - + // spare OP_cmp_T (LE, U, long, lvec2, lvec4, <=, ulong, ulvec2, ulvec4); case OP_V4QMUL_D: OPC(dvec4) = vqmuld (OPA(dvec4), OPB(dvec4)); break; - + // spare // 1 1111 - + // spare default: PR_RunError (pr, "Bad opcode o%03o", st->op & OP_MASK); } From 424bdcbf96481b9ee8980e5aa7b558f5608f9441 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 10 Jan 2022 17:05:57 +0900 Subject: [PATCH 089/360] [gamecode] Implement the scale instructions Both float 2,3,4 vectors and double 2,3,4 vectors (1 would be just a copy of the mul instructions). This completes the currently planned instructions. Now for testing. --- libs/gamecode/pr_exec.c | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 684205b80..fda0763d9 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -3313,12 +3313,28 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_SWIZZLE_F: OPC(ivec4) = pr_swizzle_f (OPA(ivec4), st->b); break; - //FIXME scale ops + case OP_SCALE_F_2: + OPC(vec2) = OPA(vec2) * OPB(float); + break; + case OP_SCALE_F_3: + VectorScale (&OPA(float), OPB(float), &OPC(float)); + break; + case OP_SCALE_F_4: + OPC(vec4) = OPA(vec4) * OPB(float); + break; OP_cmp_T (LT, U, long, lvec2, lvec4, <, ulong, ulvec2, ulvec4); case OP_SWIZZLE_D: OPC(lvec4) = pr_swizzle_d (OPA(lvec4), st->b); break; - //FIXME scale ops + case OP_SCALE_D_2: + OPC(dvec2) = OPA(dvec2) * OPB(double); + break; + case OP_SCALE_D_3: + VectorScale (&OPA(double), OPB(double), &OPC(double)); + break; + case OP_SCALE_D_4: + OPC(dvec4) = OPA(dvec4) * OPB(double); + break; // 1 1010 OP_cmp_T (GT, u, int, ivec2, ivec4, >, uint, uivec2, uivec4); // spare From 6f6f47e27e1454116398430e3b25c8a86690eec9 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 13 Jan 2022 14:24:11 +0900 Subject: [PATCH 090/360] [gamecode] Drop bool ops in favor of long bit ops I realized that being able to do bit-wise operations with 64-bit values (and 256-bit vectors) is far more important than some convenient boolean logic operators. The logic ops can be handled via the bit-wise ops so long as the values are all properly boolean, and I plan on adding some boolean conversion ope, so no real loss. --- libs/gamecode/opcodes.py | 27 +++++---------------------- libs/gamecode/pr_exec.c | 39 ++++----------------------------------- 2 files changed, 9 insertions(+), 57 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 94c115492..0596636c7 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -20,7 +20,6 @@ bitmap_txt = """ 1 011r tuss shiftops 1 0110 o1oo string 1 1ccc t0ss compare2 -1 1000 ooss bitops 1 1001 t1ss scale 1 1001 t100 swizzle 1 1010 d1xx @@ -35,7 +34,7 @@ bitmap_txt = """ 1 1101 11oo memset 1 1110 d1xx 1 11dd t100 vecops2 -1 1100 ooss boolops +1 1t00 ooss bitops n 1111 nnnn 0 1011 nnnn """ @@ -77,14 +76,16 @@ any_formats = { "types": "ev_integer, ev_integer, ev_integer", } bitops_formats = { - "opcode": "OP_{op_bit[oo].upper()}_I_{ss+1}", + "opcode": "OP_{op_bit[oo].upper()}_{bit_type[t]}_{ss+1}", "mnemonic": "{op_bit[oo]}", "opname": "{op_bit[oo]}", "format": "{bit_fmt[oo]}", "widths": "{ss+1}, {ss+1}, {ss+1}", - "types": "ev_integer, ev_integer, ev_integer", + "types": "{bit_types[t]}, {bit_types[t]}, {bit_types[t]}", "args": { "op_bit": ["bitand", "bitor", "bitxor", "bitnot"], + "bit_type": ["I", "L"], + "bit_types": ["ev_integer", "ev_long"], "bit_fmt": [ "%Ga, %Gb, %gc", "%Ga, %Gb, %gc", @@ -93,23 +94,6 @@ bitops_formats = { ], }, } -boolops_formats = { - "opcode": "OP_{op_bool[oo].upper()}_I_{ss+1}", - "mnemonic": "{op_bool[oo]}", - "opname": "{op_bool[oo]}", - "format": "{bool_fmt[oo]}", - "widths": "{ss+1}, {ss+1}, {ss+1}", - "types": "ev_integer, ev_integer, ev_integer", - "args": { - "op_bool": ["and", "or", "xor", "not"], - "bool_fmt": [ - "%Ga, %Gb, %gc", - "%Ga, %Gb, %gc", - "%Ga, %Gb, %gc", - "%Ga, %gc", - ], - }, -} branch_formats = { "opcode": "OP_{op_cond[ccc].upper()}_{op_mode[mm]}", "mnemonic": "{op_cond[ccc]}", @@ -471,7 +455,6 @@ group_map = { "all": all_formats, "any": any_formats, "bitops": bitops_formats, - "boolops": boolops_formats, "branch": branch_formats, "call": call_formats, "compare": compare_formats, diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index fda0763d9..86903f7eb 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -3403,42 +3403,11 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OPC(int) = none4i (OPA(ivec4)); break; -#define OP_bool_n(OP, t, n, op, m) \ - case OP_##OP##_I_##n: \ - OPC(t) = m((OPA(t) != 0) op (OPB(t) != 0)); \ - break -#define OP_bool_3(OP, t, n, op, m) \ - case OP_##OP##_I_##n: \ - { \ - __auto_type a = loadvec3i (&OPA(int)); \ - __auto_type b = loadvec3i (&OPB(int)); \ - storevec3i (&OPC(int), (a != 0) op (b != 0)); \ - } \ - break -#define OP_bool(OP, op) \ - OP_bool_n (OP, int, 1, op, -); \ - OP_bool_n (OP, ivec2, 2, op, +); \ - OP_bool_3 (OP, int, 3, op, +); \ - OP_bool_n (OP, ivec4, 4, op, +) -#define OP_not_n(OP, t, n, m) \ - case OP_##OP##_I_##n: \ - OPC(t) = m((OPA(t) == 0)); \ - break -#define OP_not_3(OP, t, n, m) \ - case OP_##OP##_I_##n: \ - { \ - __auto_type a = loadvec3i (&OPA(int)); \ - storevec3i (&OPC(int), (a == 0)); \ - } \ - break // 1 1100 - OP_bool (AND, &); - OP_bool (OR, |); - OP_bool (XOR, ^); - OP_not_n (NOT, int, 1, -); - OP_not_n (NOT, ivec2, 2, +); - OP_not_3 (NOT, int, 3, +); - OP_not_n (NOT, ivec4, 4, +); + OP_op_T (BITAND, L, long, lvec2, lvec4, &); + OP_op_T (BITOR, L, long, lvec2, lvec4, |); + OP_op_T (BITXOR, L, long, lvec2, lvec4, ^); + OP_uop_T (BITNOT, L, long, lvec2, lvec4, ~); // 1 1101 OP_cmp_T (GE, u, int, ivec2, ivec4, >=, uint, uivec2, uivec4); case OP_QV4MUL_F: From 3eb2194343a69f7010c985df74bbc821745d04d5 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 13 Jan 2022 15:58:12 +0900 Subject: [PATCH 091/360] [gamecode] Invert the meaning of the skip matrix Rather than specifying that the conversion should be skipped, it now specifies the mode of the conversions (with 0 being no conversion). This is in preparation for boolean conversion. --- libs/gamecode/convert.py | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/libs/gamecode/convert.py b/libs/gamecode/convert.py index 380a5526e..c3bade9f3 100644 --- a/libs/gamecode/convert.py +++ b/libs/gamecode/convert.py @@ -34,22 +34,23 @@ vec_types = [ "ulvec", None, # no such thing as unsigned double ] -skip_matrix = [ +convert_matrix = [ #i f l d ui X ul X - [1, 0, 0, 0, 1, 1, 0, 1], # i - [0, 1, 0, 0, 0, 1, 0, 1], # f - [0, 0, 1, 0, 0, 1, 1, 1], # l - [0, 0, 0, 1, 0, 1, 0, 1], # d + [0, 1, 1, 1, 0, 0, 1, 0], # i + [1, 0, 1, 1, 1, 0, 1, 0], # f + [1, 1, 0, 1, 1, 0, 0, 0], # l + [1, 1, 1, 0, 1, 0, 1, 0], # d - [1, 0, 0, 0, 1, 1, 0, 1], # ui - [1, 1, 1, 1, 1, 1, 1, 1], # X - [0, 0, 1, 0, 0, 1, 1, 1], # ul - [1, 1, 1, 1, 1, 1, 1, 1], # X + [0, 1, 1, 1, 0, 0, 1, 0], # ui + [0, 0, 0, 0, 0, 0, 0, 0], # X + [1, 1, 0, 1, 1, 0, 0, 0], # ul + [0, 0, 0, 0, 0, 0, 0, 0], # X ] for width in range(4): for src_type in range(8): for dst_type in range(8): - if skip_matrix[src_type][dst_type]: + mode = convert_matrix[src_type][dst_type] + if not mode: continue case = (width << 6) | (src_type << 3) | (dst_type) if width == 0: From ba1d73200fb0c1d795de3c699b954be779a7786f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 13 Jan 2022 16:10:06 +0900 Subject: [PATCH 092/360] [gamecode] Clean up a pile of duplicate code All those duplicated formats were getting unwieldy, especially as I want to add more conversion modes. --- libs/gamecode/convert.py | 38 ++++++++++++++++++++++++++++++++------ 1 file changed, 32 insertions(+), 6 deletions(-) diff --git a/libs/gamecode/convert.py b/libs/gamecode/convert.py index c3bade9f3..f3ef5375a 100644 --- a/libs/gamecode/convert.py +++ b/libs/gamecode/convert.py @@ -46,22 +46,48 @@ convert_matrix = [ [1, 1, 0, 1, 1, 0, 0, 0], # ul [0, 0, 0, 0, 0, 0, 0, 0], # X ] + +def case_str(width, src_type, dst_type): + case = (width << 6) | (src_type << 3) | (dst_type) + return f"case {case:04o}:" + +def cast_str(width, src_type, dst_type): + if width & 1 and (src_type & 2) == (dst_type & 2): + return f"(pr_{vec_types[dst_type]}{width+1}_t)" + else: + return f"(pr_{types[dst_type]}_t)" + +def src_str(width, src_type, dst_type): + if width & 1 and (src_type & 2) == (dst_type & 2): + return f"OPA({vec_types[src_type]}{width+1})" + else: + return f"OPA({types[src_type]})" + +def dst_str(width, src_type, dst_type): + if width & 1 and (src_type & 2) == (dst_type & 2): + return f"OPC({vec_types[dst_type]}{width+1})" + else: + return f"OPC({types[dst_type]})" + for width in range(4): for src_type in range(8): for dst_type in range(8): mode = convert_matrix[src_type][dst_type] if not mode: continue - case = (width << 6) | (src_type << 3) | (dst_type) + case = case_str(width, src_type, dst_type) + cast = cast_str(width, src_type, dst_type) + src = src_str(width, src_type, dst_type) + dst = dst_str(width, src_type, dst_type) if width == 0: - print(f"case {case:04o}: OPC({types[dst_type]}) = (pr_{types[dst_type]}_t) OPA({types[src_type]}); break;") + print(f"{case} {dst} = {cast} {src}; break;") elif width == 2: - print(f"case {case:04o}: VectorCompUop(&OPC({types[dst_type]}), (pr_{types[dst_type]}_t), &OPA({types[src_type]})); break;") + print(f"{case} VectorCompUop(&{dst}, {cast}, &{src}); break;") else: if (src_type & 2) == (dst_type & 2): - print(f"case {case:04o}: OPC({vec_types[dst_type]}{width+1}) = (pr_{vec_types[dst_type]}{width+1}_t) OPA({vec_types[src_type]}{width+1}); break;") + print(f"{case} {dst} = {cast} {src}; break;") else: - print(f"case {case:04o}:") + print(f"{case}") for i in range(width + 1): - print(f"\t(&OPC({types[dst_type]}))[{i}] = (pr_{types[dst_type]}_t) (&OPA({types[src_type]}))[{i}];") + print(f"\t(&{dst})[{i}] = {cast} (&{src})[{i}];") print(f"\tbreak;") From e8e0a6962873c285b05e196c8f52c9b4b64ea642 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 13 Jan 2022 17:37:44 +0900 Subject: [PATCH 093/360] [gamecode] Add conversions to/from bool For now, from bool results in 0/1, but conversion to bool guarantees 0/-1 and correct interpretations for floating point types. --- libs/gamecode/convert.py | 84 +++++++++++++++++++++++++++++----------- 1 file changed, 61 insertions(+), 23 deletions(-) diff --git a/libs/gamecode/convert.py b/libs/gamecode/convert.py index f3ef5375a..eb8fd2c39 100644 --- a/libs/gamecode/convert.py +++ b/libs/gamecode/convert.py @@ -2,6 +2,7 @@ print("""// types are encoded as ubf where: // u = 0: signed, u = 1: unsigned // b = 0: 32-bit, b = 1: 64-bit // f = 0: int, f = 1: float/double +// unsigned float/double is interpreted as bool // width is ww where: // ww = 00: 1 component // ww = 01: 2 components @@ -19,9 +20,9 @@ types = [ "long", "double", "uint", - None, # no such thing as unsigned float + "int", # 32-bit bool "ulong", - None, # no such thing as unsigned double + "long", # 64-bit bool ] #does not include size (2 or 4, 3 is special) vec_types = [ @@ -30,21 +31,21 @@ vec_types = [ "lvec", "dvec", "uivec", - None, # no such thing as unsigned float + "ivec", # 32-bit bool "ulvec", - None, # no such thing as unsigned double + "lvec", # 64-bit bool ] convert_matrix = [ - #i f l d ui X ul X - [0, 1, 1, 1, 0, 0, 1, 0], # i - [1, 0, 1, 1, 1, 0, 1, 0], # f - [1, 1, 0, 1, 1, 0, 0, 0], # l - [1, 1, 1, 0, 1, 0, 1, 0], # d + #i f l d ui b ul B + [0, 1, 1, 1, 0, 3, 1, 3], # i + [1, 0, 1, 1, 1, 3, 1, 3], # f + [1, 1, 0, 1, 1, 3, 0, 3], # l + [1, 1, 1, 0, 1, 3, 1, 3], # d - [0, 1, 1, 1, 0, 0, 1, 0], # ui - [0, 0, 0, 0, 0, 0, 0, 0], # X - [1, 1, 0, 1, 1, 0, 0, 0], # ul - [0, 0, 0, 0, 0, 0, 0, 0], # X + [0, 1, 1, 1, 0, 3, 1, 3], # ui + [2, 2, 2, 2, 2, 0, 2, 1], # 32-bit bool + [1, 1, 0, 1, 1, 3, 0, 3], # ul + [2, 2, 2, 2, 2, 1, 2, 0], # 64-bit bool ] def case_str(width, src_type, dst_type): @@ -69,6 +70,14 @@ def dst_str(width, src_type, dst_type): else: return f"OPC({types[dst_type]})" +def zero_str(width, src_type): + ones = "{%s}" % (", ".join(["0"] * (width + 1))) + return f"{cast_str(width, src_type, src_type)} {ones}" + +def one_str(width, src_type): + ones = "{%s}" % (", ".join(["1"] * (width + 1))) + return f"{cast_str(width, src_type, src_type)} {ones}" + for width in range(4): for src_type in range(8): for dst_type in range(8): @@ -79,15 +88,44 @@ for width in range(4): cast = cast_str(width, src_type, dst_type) src = src_str(width, src_type, dst_type) dst = dst_str(width, src_type, dst_type) - if width == 0: - print(f"{case} {dst} = {cast} {src}; break;") - elif width == 2: - print(f"{case} VectorCompUop(&{dst}, {cast}, &{src}); break;") - else: - if (src_type & 2) == (dst_type & 2): + if mode == 1: + if width == 0: print(f"{case} {dst} = {cast} {src}; break;") + elif width == 2: + print(f"{case} VectorCompUop(&{dst},{cast},&{src}); break;") else: - print(f"{case}") - for i in range(width + 1): - print(f"\t(&{dst})[{i}] = {cast} (&{src})[{i}];") - print(f"\tbreak;") + if (src_type & 2) == (dst_type & 2): + print(f"{case} {dst} = {cast} {src}; break;") + else: + print(f"{case}") + for i in range(width + 1): + print(f"\t(&{dst})[{i}] = {cast} (&{src})[{i}];") + print(f"\tbreak;") + elif mode == 2: + one = one_str(width, src_type) + if width == 0: + print(f"{case} {dst} = !!{src}; break;") + elif width == 2: + print(f"{case} VectorCompUop(&{dst},!!,&{src}); break;") + else: + if (src_type & 2) == (dst_type & 2): + print(f"{case} {dst} = {cast} ({src} & {one}); break;") + else: + print(f"{case}") + for i in range(width + 1): + print(f"\t(&{dst})[{i}] = !!(&{src})[{i}];") + print(f"\tbreak;") + elif mode == 3: + zero = zero_str(width, src_type) + if width == 0: + print(f"{case} {dst} = -!!{src}; break;") + elif width == 2: + print(f"{case} VectorCompUop(&{dst},-!!,&{src}); break;") + else: + if (src_type & 2) == (dst_type & 2): + print(f"{case} {dst} = {src} != {zero}; break;") + else: + print(f"{case}") + for i in range(width + 1): + print(f"\t(&{dst})[{i}] = -!!(&{src})[{i}];") + print(f"\tbreak;") From cd68455e469ce7155acb3d500f69b773a7249e9f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 14 Jan 2022 11:24:01 +0900 Subject: [PATCH 094/360] [gamecode] Add tests for converting to int They currently fail because for vector values, gcc casts the view, not the value, so vec4 cast to ivec4 simply views the bits as int rather than doing the actual conversion. --- libs/gamecode/test/Makemodule.am | 6 ++ libs/gamecode/test/test-conv0.c | 176 +++++++++++++++++++++++++++++++ 2 files changed, 182 insertions(+) create mode 100644 libs/gamecode/test/test-conv0.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index af16fe67f..dc5e6dabd 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -1,4 +1,5 @@ libs_gamecode_tests = \ + libs/gamecode/test/test-conv0 \ libs/gamecode/test/test-double \ libs/gamecode/test/test-float \ libs/gamecode/test/test-int \ @@ -19,6 +20,11 @@ test_gamecode_libs= \ libs/gamecode/libQFgamecode.la \ libs/util/libQFutil.la +libs_gamecode_test_test_conv0_SOURCES= \ + libs/gamecode/test/test-conv0.c +libs_gamecode_test_test_conv0_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_conv0_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_double_SOURCES= \ libs/gamecode/test/test-double.c libs_gamecode_test_test_double_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-conv0.c b/libs/gamecode/test/test-conv0.c new file mode 100644 index 000000000..e6d6b6ad7 --- /dev/null +++ b/libs/gamecode/test/test-conv0.c @@ -0,0 +1,176 @@ +#include "head.c" + +#include "QF/mathlib.h" + +static pr_ivec4_t int_conv_init[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float 1e30, -1e30 + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_ivec4_t int_conv_expect[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 0, 0, 0, 0}, // int + { 1, -1, 0x80000000, 0x80000000}, // float + { 99, 0x80000000, 256, 0x7fffffff}, // long + { 0x80000000, 0x80000000, 1, -1}, // double + { 0, 0, 0, 0}, // uint + { 1, 1, 1, 0}, // bool32 + { 99, 0x80000000, 256, 0x7fffffff}, // ulong + { 1, 1, 1, 0}, // bool64 +}; + +static dstatement_t int_conv_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 80 }, // init index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 81 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 80, -1, 80 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 81, -2, 81 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, + { OP(1, 1, 1, OP_CONV), 4, 0010, 52 }, + { OP(2, 1, 1, OP_CONV), 8, 0020, 56 }, + { OP(2, 1, 1, OP_CONV), 16, 0030, 60 }, + { OP(1, 1, 1, OP_CONV), 28, 0050, 68 }, + { OP(2, 1, 1, OP_CONV), 32, 0060, 72 }, + { OP(2, 1, 1, OP_CONV), 40, 0070, 76 }, + { OP(1, 1, 1, OP_JUMP_A), -12, 0, 0 }, +}; + +static dstatement_t int_conv_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 80 }, // index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 81 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 80, -2, 80 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 81, -4, 81 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, + { OP(1, 1, 1, OP_CONV), 4, 0110, 52 }, + { OP(2, 1, 1, OP_CONV), 8, 0120, 56 }, + { OP(2, 1, 1, OP_CONV), 16, 0130, 60 }, + { OP(1, 1, 1, OP_CONV), 28, 0150, 68 }, + { OP(2, 1, 1, OP_CONV), 32, 0160, 72 }, + { OP(2, 1, 1, OP_CONV), 40, 0170, 76 }, + { OP(1, 1, 1, OP_JUMP_A), -12, 0, 0 }, +}; + +static dstatement_t int_conv_3a_statements[] = { + { OP(1, 1, 1, OP_CONV), 4, 0210, 52 }, + { OP(1, 1, 1, OP_CONV), 7, 0010, 55 }, + { OP(2, 1, 1, OP_CONV), 8, 0220, 56 }, + { OP(2, 1, 1, OP_CONV), 14, 0020, 59 }, + { OP(2, 1, 1, OP_CONV), 16, 0230, 60 }, + { OP(2, 1, 1, OP_CONV), 22, 0030, 63 }, + { OP(1, 1, 1, OP_CONV), 28, 0250, 68 }, + { OP(1, 1, 1, OP_CONV), 31, 0050, 71 }, + { OP(2, 1, 1, OP_CONV), 32, 0260, 72 }, + { OP(2, 1, 1, OP_CONV), 38, 0060, 75 }, + { OP(2, 1, 1, OP_CONV), 40, 0270, 76 }, + { OP(2, 1, 1, OP_CONV), 46, 0070, 79 }, +}; + +static dstatement_t int_conv_3b_statements[] = { + { OP(1, 1, 1, OP_CONV), 4, 0010, 52 }, + { OP(1, 1, 1, OP_CONV), 5, 0210, 53 }, + { OP(2, 1, 1, OP_CONV), 8, 0020, 56 }, + { OP(2, 1, 1, OP_CONV), 10, 0220, 57 }, + { OP(2, 1, 1, OP_CONV), 16, 0030, 60 }, + { OP(2, 1, 1, OP_CONV), 18, 0230, 61 }, + { OP(1, 1, 1, OP_CONV), 28, 0050, 68 }, + { OP(1, 1, 1, OP_CONV), 29, 0250, 69 }, + { OP(2, 1, 1, OP_CONV), 32, 0060, 72 }, + { OP(2, 1, 1, OP_CONV), 34, 0260, 73 }, + { OP(2, 1, 1, OP_CONV), 40, 0070, 76 }, + { OP(2, 1, 1, OP_CONV), 42, 0270, 77 }, +}; + +static dstatement_t int_conv_4_statements[] = { + { OP(1, 1, 1, OP_CONV), 4, 0310, 52 }, + { OP(2, 1, 1, OP_CONV), 8, 0320, 56 }, + { OP(2, 1, 1, OP_CONV), 16, 0330, 60 }, + { OP(1, 1, 1, OP_CONV), 28, 0350, 68 }, + { OP(2, 1, 1, OP_CONV), 32, 0360, 72 }, + { OP(2, 1, 1, OP_CONV), 40, 0370, 76 }, +}; + +test_t tests[] = { + { + .desc = "int conv 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_conv_init,int_conv_expect), + .num_statements = num_statements (int_conv_1_statements), + .statements = int_conv_1_statements, + .init_globals = (pr_int_t *) int_conv_init, + .expect_globals = (pr_int_t *) int_conv_expect, + }, + { + .desc = "int conv 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_conv_init,int_conv_expect), + .num_statements = num_statements (int_conv_2_statements), + .statements = int_conv_2_statements, + .init_globals = (pr_int_t *) int_conv_init, + .expect_globals = (pr_int_t *) int_conv_expect, + }, + { + .desc = "int conv 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_conv_init,int_conv_expect), + .num_statements = num_statements (int_conv_3a_statements), + .statements = int_conv_3a_statements, + .init_globals = (pr_int_t *) int_conv_init, + .expect_globals = (pr_int_t *) int_conv_expect, + }, + { + .desc = "int conv 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_conv_init,int_conv_expect), + .num_statements = num_statements (int_conv_3b_statements), + .statements = int_conv_3b_statements, + .init_globals = (pr_int_t *) int_conv_init, + .expect_globals = (pr_int_t *) int_conv_expect, + }, + { + .desc = "int conv 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(int_conv_init,int_conv_expect), + .num_statements = num_statements (int_conv_4_statements), + .statements = int_conv_4_statements, + .init_globals = (pr_int_t *) int_conv_init, + .expect_globals = (pr_int_t *) int_conv_expect, + }, +}; + +#include "main.c" From e26fb49df73e867fcac32de7957603ca9a6464bb Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 14 Jan 2022 11:57:43 +0900 Subject: [PATCH 095/360] [gamecode] Get conversion to int working for all types Bools turned out to be a problem to due to me wanting any non-zero value to be treated as true thus had to expand them out as well as the floating point <-> integral conversions. --- libs/gamecode/convert.py | 37 +++++++++++++------------------------ 1 file changed, 13 insertions(+), 24 deletions(-) diff --git a/libs/gamecode/convert.py b/libs/gamecode/convert.py index eb8fd2c39..1a050b6a9 100644 --- a/libs/gamecode/convert.py +++ b/libs/gamecode/convert.py @@ -53,19 +53,19 @@ def case_str(width, src_type, dst_type): return f"case {case:04o}:" def cast_str(width, src_type, dst_type): - if width & 1 and (src_type & 2) == (dst_type & 2): + if width & 1: return f"(pr_{vec_types[dst_type]}{width+1}_t)" else: return f"(pr_{types[dst_type]}_t)" def src_str(width, src_type, dst_type): - if width & 1 and (src_type & 2) == (dst_type & 2): + if width & 1: return f"OPA({vec_types[src_type]}{width+1})" else: return f"OPA({types[src_type]})" def dst_str(width, src_type, dst_type): - if width & 1 and (src_type & 2) == (dst_type & 2): + if width & 1: return f"OPC({vec_types[dst_type]}{width+1})" else: return f"OPC({types[dst_type]})" @@ -78,6 +78,10 @@ def one_str(width, src_type): ones = "{%s}" % (", ".join(["1"] * (width + 1))) return f"{cast_str(width, src_type, src_type)} {ones}" +def expand_str(width, src, pref=""): + src = [f"{pref}{src}[{i}]" for i in range(width + 1)] + return "{%s}" % (", ".join(src)); + for width in range(4): for src_type in range(8): for dst_type in range(8): @@ -94,13 +98,8 @@ for width in range(4): elif width == 2: print(f"{case} VectorCompUop(&{dst},{cast},&{src}); break;") else: - if (src_type & 2) == (dst_type & 2): - print(f"{case} {dst} = {cast} {src}; break;") - else: - print(f"{case}") - for i in range(width + 1): - print(f"\t(&{dst})[{i}] = {cast} (&{src})[{i}];") - print(f"\tbreak;") + expand = expand_str(width, src) + print(f"{case} {dst} = {cast} {expand}; break;") elif mode == 2: one = one_str(width, src_type) if width == 0: @@ -108,13 +107,8 @@ for width in range(4): elif width == 2: print(f"{case} VectorCompUop(&{dst},!!,&{src}); break;") else: - if (src_type & 2) == (dst_type & 2): - print(f"{case} {dst} = {cast} ({src} & {one}); break;") - else: - print(f"{case}") - for i in range(width + 1): - print(f"\t(&{dst})[{i}] = !!(&{src})[{i}];") - print(f"\tbreak;") + expand = expand_str(width, src, "!!") + print(f"{case} {dst} = {cast} {expand}; break;") elif mode == 3: zero = zero_str(width, src_type) if width == 0: @@ -122,10 +116,5 @@ for width in range(4): elif width == 2: print(f"{case} VectorCompUop(&{dst},-!!,&{src}); break;") else: - if (src_type & 2) == (dst_type & 2): - print(f"{case} {dst} = {src} != {zero}; break;") - else: - print(f"{case}") - for i in range(width + 1): - print(f"\t(&{dst})[{i}] = -!!(&{src})[{i}];") - print(f"\tbreak;") + expand = expand_str(width, src, "-!!") + print(f"{case} {dst} = {cast} {expand}; break;") From 4bf934e6b965b3bcea59e577a8ac5a1d082ada2d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 14 Jan 2022 13:38:05 +0900 Subject: [PATCH 096/360] [gamecode] Correct incorrect bool64-bool32 conversion And add tests for float, uint and bool32 conversions. --- libs/gamecode/convert.py | 2 +- libs/gamecode/test/Makemodule.am | 18 +++ libs/gamecode/test/test-conv1.c | 183 +++++++++++++++++++++++++++++++ libs/gamecode/test/test-conv4.c | 178 ++++++++++++++++++++++++++++++ libs/gamecode/test/test-conv5.c | 183 +++++++++++++++++++++++++++++++ 5 files changed, 563 insertions(+), 1 deletion(-) create mode 100644 libs/gamecode/test/test-conv1.c create mode 100644 libs/gamecode/test/test-conv4.c create mode 100644 libs/gamecode/test/test-conv5.c diff --git a/libs/gamecode/convert.py b/libs/gamecode/convert.py index 1a050b6a9..39b407d17 100644 --- a/libs/gamecode/convert.py +++ b/libs/gamecode/convert.py @@ -45,7 +45,7 @@ convert_matrix = [ [0, 1, 1, 1, 0, 3, 1, 3], # ui [2, 2, 2, 2, 2, 0, 2, 1], # 32-bit bool [1, 1, 0, 1, 1, 3, 0, 3], # ul - [2, 2, 2, 2, 2, 1, 2, 0], # 64-bit bool + [2, 2, 2, 2, 2, 3, 2, 0], # 64-bit bool ] def case_str(width, src_type, dst_type): diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index dc5e6dabd..100873937 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -1,5 +1,8 @@ libs_gamecode_tests = \ libs/gamecode/test/test-conv0 \ + libs/gamecode/test/test-conv1 \ + libs/gamecode/test/test-conv4 \ + libs/gamecode/test/test-conv5 \ libs/gamecode/test/test-double \ libs/gamecode/test/test-float \ libs/gamecode/test/test-int \ @@ -25,6 +28,21 @@ libs_gamecode_test_test_conv0_SOURCES= \ libs_gamecode_test_test_conv0_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_conv0_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_conv1_SOURCES= \ + libs/gamecode/test/test-conv1.c +libs_gamecode_test_test_conv1_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_conv1_DEPENDENCIES= $(test_gamecode_libs) + +libs_gamecode_test_test_conv4_SOURCES= \ + libs/gamecode/test/test-conv4.c +libs_gamecode_test_test_conv4_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_conv4_DEPENDENCIES= $(test_gamecode_libs) + +libs_gamecode_test_test_conv5_SOURCES= \ + libs/gamecode/test/test-conv5.c +libs_gamecode_test_test_conv5_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_conv5_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_double_SOURCES= \ libs/gamecode/test/test-double.c libs_gamecode_test_test_double_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-conv1.c b/libs/gamecode/test/test-conv1.c new file mode 100644 index 000000000..541aa6788 --- /dev/null +++ b/libs/gamecode/test/test-conv1.c @@ -0,0 +1,183 @@ +#include "head.c" + +#include "QF/mathlib.h" + +static pr_ivec4_t float_conv_init[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float 1e30, -1e30 + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_ivec4_t float_conv_expect[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 0x40a00000, 0xc0a00000, 0xcf000000, 0x4f000000}, // int + { 0, 0, 0, 0}, // float + { 0xdf000000, 0x52c70000, 0x43800000, 0x4f000000}, // long + { 0x7149f2ca, 0xf149f2ca, 0x3fc00000, 0xbfc00000}, // double + { 0x40a00000, 0x4f800000, 0x4f000000, 0x4f000000}, // uint + { 0x3f800000, 0x3f800000, 0x3f800000, 0}, // bool32 + { 0x5f000000, 0x52c70000, 0x43800000, 0x4f000000}, // ulong + { 0x3f800000, 0x3f800000, 0x3f800000, 0}, // bool64 +}; + +static dstatement_t float_conv_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 80 }, // init index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 81 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 80, -1, 80 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 81, -2, 81 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, + { OP(1, 1, 1, OP_CONV), 0, 0001, 48 }, + { OP(2, 1, 1, OP_CONV), 8, 0021, 56 }, + { OP(2, 1, 1, OP_CONV), 16, 0031, 60 }, + { OP(1, 1, 1, OP_CONV), 24, 0041, 64 }, + { OP(1, 1, 1, OP_CONV), 28, 0051, 68 }, + { OP(2, 1, 1, OP_CONV), 32, 0061, 72 }, + { OP(2, 1, 1, OP_CONV), 40, 0071, 76 }, + { OP(1, 1, 1, OP_JUMP_A), -13, 0, 0 }, +}; + +static dstatement_t float_conv_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 80 }, // index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 81 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 80, -2, 80 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 81, -4, 81 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, + { OP(1, 1, 1, OP_CONV), 0, 0101, 48 }, + { OP(2, 1, 1, OP_CONV), 8, 0121, 56 }, + { OP(2, 1, 1, OP_CONV), 16, 0131, 60 }, + { OP(1, 1, 1, OP_CONV), 24, 0141, 64 }, + { OP(1, 1, 1, OP_CONV), 28, 0151, 68 }, + { OP(2, 1, 1, OP_CONV), 32, 0161, 72 }, + { OP(2, 1, 1, OP_CONV), 40, 0171, 76 }, + { OP(1, 1, 1, OP_JUMP_A), -13, 0, 0 }, +}; + +static dstatement_t float_conv_3a_statements[] = { + { OP(1, 1, 1, OP_CONV), 0, 0201, 48 }, + { OP(1, 1, 1, OP_CONV), 3, 0001, 51 }, + { OP(2, 1, 1, OP_CONV), 8, 0221, 56 }, + { OP(2, 1, 1, OP_CONV), 14, 0021, 59 }, + { OP(2, 1, 1, OP_CONV), 16, 0231, 60 }, + { OP(2, 1, 1, OP_CONV), 22, 0031, 63 }, + { OP(1, 1, 1, OP_CONV), 24, 0241, 64 }, + { OP(1, 1, 1, OP_CONV), 27, 0041, 67 }, + { OP(1, 1, 1, OP_CONV), 28, 0251, 68 }, + { OP(1, 1, 1, OP_CONV), 31, 0051, 71 }, + { OP(2, 1, 1, OP_CONV), 32, 0261, 72 }, + { OP(2, 1, 1, OP_CONV), 38, 0061, 75 }, + { OP(2, 1, 1, OP_CONV), 40, 0271, 76 }, + { OP(2, 1, 1, OP_CONV), 46, 0071, 79 }, +}; + +static dstatement_t float_conv_3b_statements[] = { + { OP(1, 1, 1, OP_CONV), 0, 0001, 48 }, + { OP(1, 1, 1, OP_CONV), 1, 0201, 49 }, + { OP(2, 1, 1, OP_CONV), 8, 0021, 56 }, + { OP(2, 1, 1, OP_CONV), 10, 0221, 57 }, + { OP(2, 1, 1, OP_CONV), 16, 0031, 60 }, + { OP(2, 1, 1, OP_CONV), 18, 0231, 61 }, + { OP(1, 1, 1, OP_CONV), 24, 0241, 64 }, + { OP(1, 1, 1, OP_CONV), 27, 0041, 67 }, + { OP(1, 1, 1, OP_CONV), 28, 0051, 68 }, + { OP(1, 1, 1, OP_CONV), 29, 0251, 69 }, + { OP(2, 1, 1, OP_CONV), 32, 0061, 72 }, + { OP(2, 1, 1, OP_CONV), 34, 0261, 73 }, + { OP(2, 1, 1, OP_CONV), 40, 0071, 76 }, + { OP(2, 1, 1, OP_CONV), 42, 0271, 77 }, +}; + +static dstatement_t float_conv_4_statements[] = { + { OP(1, 1, 1, OP_CONV), 0, 0301, 48 }, + { OP(2, 1, 1, OP_CONV), 8, 0321, 56 }, + { OP(2, 1, 1, OP_CONV), 16, 0331, 60 }, + { OP(1, 1, 1, OP_CONV), 24, 0341, 64 }, + { OP(1, 1, 1, OP_CONV), 28, 0351, 68 }, + { OP(2, 1, 1, OP_CONV), 32, 0361, 72 }, + { OP(2, 1, 1, OP_CONV), 40, 0371, 76 }, +}; + +test_t tests[] = { + { + .desc = "float conv 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_conv_init,float_conv_expect), + .num_statements = num_statements (float_conv_1_statements), + .statements = float_conv_1_statements, + .init_globals = (pr_int_t *) float_conv_init, + .expect_globals = (pr_int_t *) float_conv_expect, + }, + { + .desc = "float conv 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_conv_init,float_conv_expect), + .num_statements = num_statements (float_conv_2_statements), + .statements = float_conv_2_statements, + .init_globals = (pr_int_t *) float_conv_init, + .expect_globals = (pr_int_t *) float_conv_expect, + }, + { + .desc = "float conv 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_conv_init,float_conv_expect), + .num_statements = num_statements (float_conv_3a_statements), + .statements = float_conv_3a_statements, + .init_globals = (pr_int_t *) float_conv_init, + .expect_globals = (pr_int_t *) float_conv_expect, + }, + { + .desc = "float conv 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_conv_init,float_conv_expect), + .num_statements = num_statements (float_conv_3b_statements), + .statements = float_conv_3b_statements, + .init_globals = (pr_int_t *) float_conv_init, + .expect_globals = (pr_int_t *) float_conv_expect, + }, + { + .desc = "float conv 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(float_conv_init,float_conv_expect), + .num_statements = num_statements (float_conv_4_statements), + .statements = float_conv_4_statements, + .init_globals = (pr_int_t *) float_conv_init, + .expect_globals = (pr_int_t *) float_conv_expect, + }, +}; + +#include "main.c" diff --git a/libs/gamecode/test/test-conv4.c b/libs/gamecode/test/test-conv4.c new file mode 100644 index 000000000..4accd2ee8 --- /dev/null +++ b/libs/gamecode/test/test-conv4.c @@ -0,0 +1,178 @@ +#include "head.c" + +#include "QF/mathlib.h" + +static pr_ivec4_t uint_conv_init[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float 1e30, -1e30 + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_ivec4_t uint_conv_expect[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 0, 0, 0, 0}, // int + // why 0? expected 0xfffffff. vv gcc bug? + { 1, 0xffffffff, 0, 0}, // float + { 99, 0x80000000, 256, 0x7fffffff}, // long + // why 0? vv expected 0xfffffff. gcc bug? + { 0, 0, 1, 0xffffffff}, // double + { 0, 0, 0, 0}, // uint + { 1, 1, 1, 0}, // bool32 + { 99, 0x80000000, 256, 0x7fffffff}, // ulong + { 1, 1, 1, 0}, // bool64 +}; + +static dstatement_t uint_conv_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 80 }, // init index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 81 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 80, -1, 80 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 81, -2, 81 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, + { OP(1, 1, 1, OP_CONV), 4, 0014, 52 }, + { OP(2, 1, 1, OP_CONV), 8, 0024, 56 }, + { OP(2, 1, 1, OP_CONV), 16, 0034, 60 }, + { OP(1, 1, 1, OP_CONV), 28, 0054, 68 }, + { OP(2, 1, 1, OP_CONV), 32, 0064, 72 }, + { OP(2, 1, 1, OP_CONV), 40, 0074, 76 }, + { OP(1, 1, 1, OP_JUMP_A), -12, 0, 0 }, +}; + +static dstatement_t uint_conv_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 80 }, // index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 81 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 80, -2, 80 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 81, -4, 81 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, + { OP(1, 1, 1, OP_CONV), 4, 0114, 52 }, + { OP(2, 1, 1, OP_CONV), 8, 0124, 56 }, + { OP(2, 1, 1, OP_CONV), 16, 0134, 60 }, + { OP(1, 1, 1, OP_CONV), 28, 0154, 68 }, + { OP(2, 1, 1, OP_CONV), 32, 0164, 72 }, + { OP(2, 1, 1, OP_CONV), 40, 0174, 76 }, + { OP(1, 1, 1, OP_JUMP_A), -12, 0, 0 }, +}; + +static dstatement_t uint_conv_3a_statements[] = { + { OP(1, 1, 1, OP_CONV), 4, 0214, 52 }, + { OP(1, 1, 1, OP_CONV), 7, 0014, 55 }, + { OP(2, 1, 1, OP_CONV), 8, 0224, 56 }, + { OP(2, 1, 1, OP_CONV), 14, 0024, 59 }, + { OP(2, 1, 1, OP_CONV), 16, 0234, 60 }, + { OP(2, 1, 1, OP_CONV), 22, 0034, 63 }, + { OP(1, 1, 1, OP_CONV), 28, 0254, 68 }, + { OP(1, 1, 1, OP_CONV), 31, 0054, 71 }, + { OP(2, 1, 1, OP_CONV), 32, 0264, 72 }, + { OP(2, 1, 1, OP_CONV), 38, 0064, 75 }, + { OP(2, 1, 1, OP_CONV), 40, 0274, 76 }, + { OP(2, 1, 1, OP_CONV), 46, 0074, 79 }, +}; + +static dstatement_t uint_conv_3b_statements[] = { + { OP(1, 1, 1, OP_CONV), 4, 0014, 52 }, + { OP(1, 1, 1, OP_CONV), 5, 0214, 53 }, + { OP(2, 1, 1, OP_CONV), 8, 0024, 56 }, + { OP(2, 1, 1, OP_CONV), 10, 0224, 57 }, + { OP(2, 1, 1, OP_CONV), 16, 0034, 60 }, + { OP(2, 1, 1, OP_CONV), 18, 0234, 61 }, + { OP(1, 1, 1, OP_CONV), 28, 0054, 68 }, + { OP(1, 1, 1, OP_CONV), 29, 0254, 69 }, + { OP(2, 1, 1, OP_CONV), 32, 0064, 72 }, + { OP(2, 1, 1, OP_CONV), 34, 0264, 73 }, + { OP(2, 1, 1, OP_CONV), 40, 0074, 76 }, + { OP(2, 1, 1, OP_CONV), 42, 0274, 77 }, +}; + +static dstatement_t uint_conv_4_statements[] = { + { OP(1, 1, 1, OP_CONV), 4, 0314, 52 }, + { OP(2, 1, 1, OP_CONV), 8, 0324, 56 }, + { OP(2, 1, 1, OP_CONV), 16, 0334, 60 }, + { OP(1, 1, 1, OP_CONV), 28, 0354, 68 }, + { OP(2, 1, 1, OP_CONV), 32, 0364, 72 }, + { OP(2, 1, 1, OP_CONV), 40, 0374, 76 }, +}; + +test_t tests[] = { + { + .desc = "uint conv 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_conv_init,uint_conv_expect), + .num_statements = num_statements (uint_conv_1_statements), + .statements = uint_conv_1_statements, + .init_globals = (pr_int_t *) uint_conv_init, + .expect_globals = (pr_int_t *) uint_conv_expect, + }, + { + .desc = "uint conv 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_conv_init,uint_conv_expect), + .num_statements = num_statements (uint_conv_2_statements), + .statements = uint_conv_2_statements, + .init_globals = (pr_int_t *) uint_conv_init, + .expect_globals = (pr_int_t *) uint_conv_expect, + }, + { + .desc = "uint conv 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_conv_init,uint_conv_expect), + .num_statements = num_statements (uint_conv_3a_statements), + .statements = uint_conv_3a_statements, + .init_globals = (pr_int_t *) uint_conv_init, + .expect_globals = (pr_int_t *) uint_conv_expect, + }, + { + .desc = "uint conv 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_conv_init,uint_conv_expect), + .num_statements = num_statements (uint_conv_3b_statements), + .statements = uint_conv_3b_statements, + .init_globals = (pr_int_t *) uint_conv_init, + .expect_globals = (pr_int_t *) uint_conv_expect, + }, + { + .desc = "uint conv 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(uint_conv_init,uint_conv_expect), + .num_statements = num_statements (uint_conv_4_statements), + .statements = uint_conv_4_statements, + .init_globals = (pr_int_t *) uint_conv_init, + .expect_globals = (pr_int_t *) uint_conv_expect, + }, +}; + +#include "main.c" diff --git a/libs/gamecode/test/test-conv5.c b/libs/gamecode/test/test-conv5.c new file mode 100644 index 000000000..2a1d92a46 --- /dev/null +++ b/libs/gamecode/test/test-conv5.c @@ -0,0 +1,183 @@ +#include "head.c" + +#include "QF/mathlib.h" + +static pr_ivec4_t bool32_conv_init[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float 1e30, -1e30 + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_ivec4_t bool32_conv_expect[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { -1, -1, -1, -1}, // int + { -1, -1, -1, -1}, // float + { -1, -1, -1, -1}, // long + { -1, -1, -1, -1}, // double + { -1, -1, -1, -1}, // uint + { 0, 0, 0, 0}, // bool32 + { -1, -1, -1, -1}, // ulong + { -1, -1, -1, 0}, // bool64 +}; + +static dstatement_t bool32_conv_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 80 }, // init index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 81 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 80, -1, 80 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 81, -2, 81 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, + { OP(1, 1, 1, OP_CONV), 0, 0005, 48 }, + { OP(1, 1, 1, OP_CONV), 4, 0015, 52 }, + { OP(2, 1, 1, OP_CONV), 8, 0025, 56 }, + { OP(2, 1, 1, OP_CONV), 16, 0035, 60 }, + { OP(1, 1, 1, OP_CONV), 24, 0045, 64 }, + { OP(2, 1, 1, OP_CONV), 32, 0065, 72 }, + { OP(2, 1, 1, OP_CONV), 40, 0075, 76 }, + { OP(1, 1, 1, OP_JUMP_A), -13, 0, 0 }, +}; + +static dstatement_t bool32_conv_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 80 }, // index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 81 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 80, -2, 80 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 81, -4, 81 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, + { OP(1, 1, 1, OP_CONV), 0, 0105, 48 }, + { OP(1, 1, 1, OP_CONV), 4, 0115, 52 }, + { OP(2, 1, 1, OP_CONV), 8, 0125, 56 }, + { OP(2, 1, 1, OP_CONV), 16, 0135, 60 }, + { OP(1, 1, 1, OP_CONV), 24, 0145, 64 }, + { OP(2, 1, 1, OP_CONV), 32, 0165, 72 }, + { OP(2, 1, 1, OP_CONV), 40, 0175, 76 }, + { OP(1, 1, 1, OP_JUMP_A), -13, 0, 0 }, +}; + +static dstatement_t bool32_conv_3a_statements[] = { + { OP(1, 1, 1, OP_CONV), 0, 0205, 48 }, + { OP(1, 1, 1, OP_CONV), 3, 0005, 51 }, + { OP(1, 1, 1, OP_CONV), 4, 0215, 52 }, + { OP(1, 1, 1, OP_CONV), 7, 0015, 55 }, + { OP(2, 1, 1, OP_CONV), 8, 0225, 56 }, + { OP(2, 1, 1, OP_CONV), 14, 0025, 59 }, + { OP(2, 1, 1, OP_CONV), 16, 0235, 60 }, + { OP(2, 1, 1, OP_CONV), 22, 0035, 63 }, + { OP(1, 1, 1, OP_CONV), 24, 0245, 64 }, + { OP(1, 1, 1, OP_CONV), 27, 0045, 67 }, + { OP(2, 1, 1, OP_CONV), 32, 0265, 72 }, + { OP(2, 1, 1, OP_CONV), 38, 0065, 75 }, + { OP(2, 1, 1, OP_CONV), 40, 0275, 76 }, + { OP(2, 1, 1, OP_CONV), 46, 0075, 79 }, +}; + +static dstatement_t bool32_conv_3b_statements[] = { + { OP(1, 1, 1, OP_CONV), 0, 0005, 48 }, + { OP(1, 1, 1, OP_CONV), 1, 0205, 49 }, + { OP(1, 1, 1, OP_CONV), 4, 0015, 52 }, + { OP(1, 1, 1, OP_CONV), 5, 0215, 53 }, + { OP(2, 1, 1, OP_CONV), 8, 0025, 56 }, + { OP(2, 1, 1, OP_CONV), 10, 0225, 57 }, + { OP(2, 1, 1, OP_CONV), 16, 0035, 60 }, + { OP(2, 1, 1, OP_CONV), 18, 0235, 61 }, + { OP(1, 1, 1, OP_CONV), 24, 0045, 64 }, + { OP(1, 1, 1, OP_CONV), 25, 0245, 65 }, + { OP(2, 1, 1, OP_CONV), 32, 0065, 72 }, + { OP(2, 1, 1, OP_CONV), 34, 0265, 73 }, + { OP(2, 1, 1, OP_CONV), 40, 0075, 76 }, + { OP(2, 1, 1, OP_CONV), 42, 0275, 77 }, +}; + +static dstatement_t bool32_conv_4_statements[] = { + { OP(1, 1, 1, OP_CONV), 0, 0305, 48 }, + { OP(1, 1, 1, OP_CONV), 4, 0315, 52 }, + { OP(2, 1, 1, OP_CONV), 8, 0325, 56 }, + { OP(2, 1, 1, OP_CONV), 16, 0335, 60 }, + { OP(1, 1, 1, OP_CONV), 24, 0345, 64 }, + { OP(2, 1, 1, OP_CONV), 32, 0365, 72 }, + { OP(2, 1, 1, OP_CONV), 40, 0375, 76 }, +}; + +test_t tests[] = { + { + .desc = "bool32 conv 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(bool32_conv_init,bool32_conv_expect), + .num_statements = num_statements (bool32_conv_1_statements), + .statements = bool32_conv_1_statements, + .init_globals = (pr_int_t *) bool32_conv_init, + .expect_globals = (pr_int_t *) bool32_conv_expect, + }, + { + .desc = "bool32 conv 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(bool32_conv_init,bool32_conv_expect), + .num_statements = num_statements (bool32_conv_2_statements), + .statements = bool32_conv_2_statements, + .init_globals = (pr_int_t *) bool32_conv_init, + .expect_globals = (pr_int_t *) bool32_conv_expect, + }, + { + .desc = "bool32 conv 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(bool32_conv_init,bool32_conv_expect), + .num_statements = num_statements (bool32_conv_3a_statements), + .statements = bool32_conv_3a_statements, + .init_globals = (pr_int_t *) bool32_conv_init, + .expect_globals = (pr_int_t *) bool32_conv_expect, + }, + { + .desc = "bool32 conv 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(bool32_conv_init,bool32_conv_expect), + .num_statements = num_statements (bool32_conv_3b_statements), + .statements = bool32_conv_3b_statements, + .init_globals = (pr_int_t *) bool32_conv_init, + .expect_globals = (pr_int_t *) bool32_conv_expect, + }, + { + .desc = "bool32 conv 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(bool32_conv_init,bool32_conv_expect), + .num_statements = num_statements (bool32_conv_4_statements), + .statements = bool32_conv_4_statements, + .init_globals = (pr_int_t *) bool32_conv_init, + .expect_globals = (pr_int_t *) bool32_conv_expect, + }, +}; + +#include "main.c" From 1f73b26d24b07c3bf7fb950ffaf5399ca0ce947a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 14 Jan 2022 14:54:35 +0900 Subject: [PATCH 097/360] [gamecode] Correct incorrect bool32-bool64 conversion And add tests for long, ulong and bool64 conversions. --- libs/gamecode/convert.py | 2 +- libs/gamecode/test/Makemodule.am | 18 +++ libs/gamecode/test/test-conv2.c | 192 +++++++++++++++++++++++++++++ libs/gamecode/test/test-conv6.c | 192 +++++++++++++++++++++++++++++ libs/gamecode/test/test-conv7.c | 199 +++++++++++++++++++++++++++++++ 5 files changed, 602 insertions(+), 1 deletion(-) create mode 100644 libs/gamecode/test/test-conv2.c create mode 100644 libs/gamecode/test/test-conv6.c create mode 100644 libs/gamecode/test/test-conv7.c diff --git a/libs/gamecode/convert.py b/libs/gamecode/convert.py index 39b407d17..dc4b36674 100644 --- a/libs/gamecode/convert.py +++ b/libs/gamecode/convert.py @@ -43,7 +43,7 @@ convert_matrix = [ [1, 1, 1, 0, 1, 3, 1, 3], # d [0, 1, 1, 1, 0, 3, 1, 3], # ui - [2, 2, 2, 2, 2, 0, 2, 1], # 32-bit bool + [2, 2, 2, 2, 2, 0, 2, 3], # 32-bit bool [1, 1, 0, 1, 1, 3, 0, 3], # ul [2, 2, 2, 2, 2, 3, 2, 0], # 64-bit bool ] diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index 100873937..560425a5e 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -1,8 +1,11 @@ libs_gamecode_tests = \ libs/gamecode/test/test-conv0 \ libs/gamecode/test/test-conv1 \ + libs/gamecode/test/test-conv2 \ libs/gamecode/test/test-conv4 \ libs/gamecode/test/test-conv5 \ + libs/gamecode/test/test-conv6 \ + libs/gamecode/test/test-conv7 \ libs/gamecode/test/test-double \ libs/gamecode/test/test-float \ libs/gamecode/test/test-int \ @@ -33,6 +36,11 @@ libs_gamecode_test_test_conv1_SOURCES= \ libs_gamecode_test_test_conv1_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_conv1_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_conv2_SOURCES= \ + libs/gamecode/test/test-conv2.c +libs_gamecode_test_test_conv2_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_conv2_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_conv4_SOURCES= \ libs/gamecode/test/test-conv4.c libs_gamecode_test_test_conv4_LDADD= $(test_gamecode_libs) @@ -43,6 +51,16 @@ libs_gamecode_test_test_conv5_SOURCES= \ libs_gamecode_test_test_conv5_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_conv5_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_conv6_SOURCES= \ + libs/gamecode/test/test-conv6.c +libs_gamecode_test_test_conv6_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_conv6_DEPENDENCIES= $(test_gamecode_libs) + +libs_gamecode_test_test_conv7_SOURCES= \ + libs/gamecode/test/test-conv7.c +libs_gamecode_test_test_conv7_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_conv7_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_double_SOURCES= \ libs/gamecode/test/test-double.c libs_gamecode_test_test_double_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-conv2.c b/libs/gamecode/test/test-conv2.c new file mode 100644 index 000000000..654dd4c90 --- /dev/null +++ b/libs/gamecode/test/test-conv2.c @@ -0,0 +1,192 @@ +#include "head.c" + +#include "QF/mathlib.h" + +static pr_ivec4_t long_conv_init[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float 1e30, -1e30 + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_ivec4_t long_conv_expect[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 5, 0, -5, 0xffffffff}, // int + { 0x80000000, 0xffffffff, 0x7fffffff, 0}, + { 1, 0, -1, -1}, // float + { 0, 0x80000000, 0, 0x80000000}, + { 0, 0, 0, 0}, // long + { 0, 0, 0, 0}, + { 0, 0x80000000, 0, 0x80000000}, // double + { 1, 0, -1, -1}, + { 5, 0, -5, 0}, // uint + { 0x80000000, 0, 0x7fffffff, 0}, + { 1, 0, 1, 0}, // bool32 + { 1, 0, 0, 0}, + { 0, 0, 0, 0}, // ulong + { 0, 0, 0, 0}, + { 1, 0, 1, 0}, // bool64 + { 1, 0, 0, 0}, +}; + +static dstatement_t long_conv_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 112 }, // init index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 113 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 112, -1, 112 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 113, -2, 113 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, + { OP(1, 1, 2, OP_CONV), 0, 0002, 48 }, + { OP(1, 1, 2, OP_CONV), 4, 0012, 56 }, + { OP(2, 1, 2, OP_CONV), 16, 0032, 72 }, + { OP(1, 1, 2, OP_CONV), 24, 0042, 80 }, + { OP(1, 1, 2, OP_CONV), 28, 0052, 88 }, + { OP(2, 1, 2, OP_CONV), 40, 0072, 104 }, + { OP(0, 0, 0, OP_JUMP_A), -12, 0, 0 }, +}; + +static dstatement_t long_conv_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 112 }, // index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 113 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 112, -2, 112 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 113, -4, 113 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, + { OP(1, 1, 2, OP_CONV), 0, 0102, 48 }, + { OP(1, 1, 2, OP_CONV), 4, 0112, 56 }, + { OP(2, 1, 2, OP_CONV), 16, 0132, 72 }, + { OP(1, 1, 2, OP_CONV), 24, 0142, 80 }, + { OP(1, 1, 2, OP_CONV), 28, 0152, 88 }, + { OP(2, 1, 2, OP_CONV), 40, 0172, 104 }, + { OP(0, 0, 0, OP_JUMP_A), -12, 0, 0 }, +}; + +static dstatement_t long_conv_3a_statements[] = { + { OP(1, 1, 2, OP_CONV), 0, 0202, 48 }, + { OP(1, 1, 2, OP_CONV), 3, 0002, 54 }, + { OP(1, 1, 2, OP_CONV), 4, 0212, 56 }, + { OP(1, 1, 2, OP_CONV), 7, 0012, 62 }, + { OP(2, 1, 2, OP_CONV), 16, 0232, 72 }, + { OP(2, 1, 2, OP_CONV), 22, 0032, 78 }, + { OP(1, 1, 2, OP_CONV), 24, 0242, 80 }, + { OP(1, 1, 2, OP_CONV), 27, 0042, 86 }, + { OP(1, 1, 2, OP_CONV), 28, 0252, 88 }, + { OP(1, 1, 2, OP_CONV), 31, 0052, 94 }, + { OP(2, 1, 2, OP_CONV), 40, 0272, 104 }, + { OP(2, 1, 2, OP_CONV), 46, 0072, 110 }, +}; + +static dstatement_t long_conv_3b_statements[] = { + { OP(1, 1, 2, OP_CONV), 0, 0002, 48 }, + { OP(1, 1, 2, OP_CONV), 1, 0202, 50 }, + { OP(1, 1, 2, OP_CONV), 4, 0012, 56 }, + { OP(1, 1, 2, OP_CONV), 5, 0212, 58 }, + { OP(2, 1, 2, OP_CONV), 16, 0032, 72 }, + { OP(2, 1, 2, OP_CONV), 18, 0232, 74 }, + { OP(1, 1, 2, OP_CONV), 24, 0042, 80 }, + { OP(1, 1, 2, OP_CONV), 25, 0242, 82 }, + { OP(1, 1, 2, OP_CONV), 28, 0052, 88 }, + { OP(1, 1, 2, OP_CONV), 29, 0252, 90 }, + { OP(2, 1, 2, OP_CONV), 40, 0072, 104 }, + { OP(2, 1, 2, OP_CONV), 42, 0272, 106 }, +}; + +static dstatement_t long_conv_4_statements[] = { + { OP(1, 1, 2, OP_CONV), 0, 0302, 48 }, + { OP(1, 1, 2, OP_CONV), 4, 0312, 56 }, + { OP(2, 1, 2, OP_CONV), 16, 0332, 72 }, + { OP(1, 1, 2, OP_CONV), 24, 0342, 80 }, + { OP(1, 1, 2, OP_CONV), 28, 0352, 88 }, + { OP(2, 1, 2, OP_CONV), 40, 0372, 104 }, +}; + +test_t tests[] = { + { + .desc = "long conv 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(long_conv_init,long_conv_expect), + .num_statements = num_statements (long_conv_1_statements), + .statements = long_conv_1_statements, + .init_globals = (pr_int_t *) long_conv_init, + .expect_globals = (pr_int_t *) long_conv_expect, + }, + { + .desc = "long conv 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(long_conv_init,long_conv_expect), + .num_statements = num_statements (long_conv_2_statements), + .statements = long_conv_2_statements, + .init_globals = (pr_int_t *) long_conv_init, + .expect_globals = (pr_int_t *) long_conv_expect, + }, + { + .desc = "long conv 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(long_conv_init,long_conv_expect), + .num_statements = num_statements (long_conv_3a_statements), + .statements = long_conv_3a_statements, + .init_globals = (pr_int_t *) long_conv_init, + .expect_globals = (pr_int_t *) long_conv_expect, + }, + { + .desc = "long conv 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(long_conv_init,long_conv_expect), + .num_statements = num_statements (long_conv_3b_statements), + .statements = long_conv_3b_statements, + .init_globals = (pr_int_t *) long_conv_init, + .expect_globals = (pr_int_t *) long_conv_expect, + }, + { + .desc = "long conv 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(long_conv_init,long_conv_expect), + .num_statements = num_statements (long_conv_4_statements), + .statements = long_conv_4_statements, + .init_globals = (pr_int_t *) long_conv_init, + .expect_globals = (pr_int_t *) long_conv_expect, + }, +}; + +#include "main.c" diff --git a/libs/gamecode/test/test-conv6.c b/libs/gamecode/test/test-conv6.c new file mode 100644 index 000000000..a5d4f7881 --- /dev/null +++ b/libs/gamecode/test/test-conv6.c @@ -0,0 +1,192 @@ +#include "head.c" + +#include "QF/mathlib.h" + +static pr_ivec4_t ulong_conv_init[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float 1e30, -1e30 + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_ivec4_t ulong_conv_expect[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 5, 0, -5, 0xffffffff}, // int + { 0x80000000, 0xffffffff, 0x7fffffff, 0}, + { 1, 0, -1, -1}, // float + { 0, 0, 0, 0x80000000}, + { 0, 0, 0, 0}, // long + { 0, 0, 0, 0}, + { 0, 0, 0, 0x80000000}, // double + { 1, 0, -1, -1}, + { 5, 0, -5, 0}, // uint + { 0x80000000, 0, 0x7fffffff, 0}, + { 1, 0, 1, 0}, // bool32 + { 1, 0, 0, 0}, + { 0, 0, 0, 0}, // ulong + { 0, 0, 0, 0}, + { 1, 0, 1, 0}, // bool64 + { 1, 0, 0, 0}, +}; + +static dstatement_t ulong_conv_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 112 }, // init index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 113 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 112, -1, 112 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 113, -2, 113 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, + { OP(1, 1, 2, OP_CONV), 0, 0006, 48 }, + { OP(1, 1, 2, OP_CONV), 4, 0016, 56 }, + { OP(2, 1, 2, OP_CONV), 16, 0036, 72 }, + { OP(1, 1, 2, OP_CONV), 24, 0046, 80 }, + { OP(1, 1, 2, OP_CONV), 28, 0056, 88 }, + { OP(2, 1, 2, OP_CONV), 40, 0076, 104 }, + { OP(0, 0, 0, OP_JUMP_A), -12, 0, 0 }, +}; + +static dstatement_t ulong_conv_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 112 }, // index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 113 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 112, -2, 112 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 113, -4, 113 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, + { OP(1, 1, 2, OP_CONV), 0, 0106, 48 }, + { OP(1, 1, 2, OP_CONV), 4, 0116, 56 }, + { OP(2, 1, 2, OP_CONV), 16, 0136, 72 }, + { OP(1, 1, 2, OP_CONV), 24, 0146, 80 }, + { OP(1, 1, 2, OP_CONV), 28, 0156, 88 }, + { OP(2, 1, 2, OP_CONV), 40, 0176, 104 }, + { OP(0, 0, 0, OP_JUMP_A), -12, 0, 0 }, +}; + +static dstatement_t ulong_conv_3a_statements[] = { + { OP(1, 1, 2, OP_CONV), 0, 0206, 48 }, + { OP(1, 1, 2, OP_CONV), 3, 0006, 54 }, + { OP(1, 1, 2, OP_CONV), 4, 0216, 56 }, + { OP(1, 1, 2, OP_CONV), 7, 0016, 62 }, + { OP(2, 1, 2, OP_CONV), 16, 0236, 72 }, + { OP(2, 1, 2, OP_CONV), 22, 0036, 78 }, + { OP(1, 1, 2, OP_CONV), 24, 0246, 80 }, + { OP(1, 1, 2, OP_CONV), 27, 0046, 86 }, + { OP(1, 1, 2, OP_CONV), 28, 0256, 88 }, + { OP(1, 1, 2, OP_CONV), 31, 0056, 94 }, + { OP(2, 1, 2, OP_CONV), 40, 0276, 104 }, + { OP(2, 1, 2, OP_CONV), 46, 0076, 110 }, +}; + +static dstatement_t ulong_conv_3b_statements[] = { + { OP(1, 1, 2, OP_CONV), 0, 0006, 48 }, + { OP(1, 1, 2, OP_CONV), 1, 0206, 50 }, + { OP(1, 1, 2, OP_CONV), 4, 0016, 56 }, + { OP(1, 1, 2, OP_CONV), 5, 0216, 58 }, + { OP(2, 1, 2, OP_CONV), 16, 0036, 72 }, + { OP(2, 1, 2, OP_CONV), 18, 0236, 74 }, + { OP(1, 1, 2, OP_CONV), 24, 0046, 80 }, + { OP(1, 1, 2, OP_CONV), 25, 0246, 82 }, + { OP(1, 1, 2, OP_CONV), 28, 0056, 88 }, + { OP(1, 1, 2, OP_CONV), 29, 0256, 90 }, + { OP(2, 1, 2, OP_CONV), 40, 0076, 104 }, + { OP(2, 1, 2, OP_CONV), 42, 0276, 106 }, +}; + +static dstatement_t ulong_conv_4_statements[] = { + { OP(1, 1, 2, OP_CONV), 0, 0306, 48 }, + { OP(1, 1, 2, OP_CONV), 4, 0316, 56 }, + { OP(2, 1, 2, OP_CONV), 16, 0336, 72 }, + { OP(1, 1, 2, OP_CONV), 24, 0346, 80 }, + { OP(1, 1, 2, OP_CONV), 28, 0356, 88 }, + { OP(2, 1, 2, OP_CONV), 40, 0376, 104 }, +}; + +test_t tests[] = { + { + .desc = "ulong conv 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_conv_init,ulong_conv_expect), + .num_statements = num_statements (ulong_conv_1_statements), + .statements = ulong_conv_1_statements, + .init_globals = (pr_int_t *) ulong_conv_init, + .expect_globals = (pr_int_t *) ulong_conv_expect, + }, + { + .desc = "ulong conv 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_conv_init,ulong_conv_expect), + .num_statements = num_statements (ulong_conv_2_statements), + .statements = ulong_conv_2_statements, + .init_globals = (pr_int_t *) ulong_conv_init, + .expect_globals = (pr_int_t *) ulong_conv_expect, + }, + { + .desc = "ulong conv 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_conv_init,ulong_conv_expect), + .num_statements = num_statements (ulong_conv_3a_statements), + .statements = ulong_conv_3a_statements, + .init_globals = (pr_int_t *) ulong_conv_init, + .expect_globals = (pr_int_t *) ulong_conv_expect, + }, + { + .desc = "ulong conv 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_conv_init,ulong_conv_expect), + .num_statements = num_statements (ulong_conv_3b_statements), + .statements = ulong_conv_3b_statements, + .init_globals = (pr_int_t *) ulong_conv_init, + .expect_globals = (pr_int_t *) ulong_conv_expect, + }, + { + .desc = "ulong conv 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(ulong_conv_init,ulong_conv_expect), + .num_statements = num_statements (ulong_conv_4_statements), + .statements = ulong_conv_4_statements, + .init_globals = (pr_int_t *) ulong_conv_init, + .expect_globals = (pr_int_t *) ulong_conv_expect, + }, +}; + +#include "main.c" diff --git a/libs/gamecode/test/test-conv7.c b/libs/gamecode/test/test-conv7.c new file mode 100644 index 000000000..78e3a44df --- /dev/null +++ b/libs/gamecode/test/test-conv7.c @@ -0,0 +1,199 @@ +#include "head.c" + +#include "QF/mathlib.h" + +static pr_ivec4_t bool64_conv_init[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float 1e30, -1e30 + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_ivec4_t bool64_conv_expect[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, // int + { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, + { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, // float + { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, + { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, // long + { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, + { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, // double + { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, + { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, // uint + { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, + { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, // bool32 + { 0xffffffff, 0xffffffff, 0, 0}, + { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, // ulong + { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, + { 0, 0, 0, 0}, // bool64 + { 0, 0, 0, 0}, +}; + +static dstatement_t bool64_conv_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 112 }, // init index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 113 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 112, -1, 112 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 113, -2, 113 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, + { OP(1, 1, 2, OP_CONV), 0, 0007, 48 }, + { OP(1, 1, 2, OP_CONV), 4, 0017, 56 }, + { OP(1, 1, 2, OP_CONV), 8, 0027, 64 }, + { OP(2, 1, 2, OP_CONV), 16, 0037, 72 }, + { OP(1, 1, 2, OP_CONV), 24, 0047, 80 }, + { OP(1, 1, 2, OP_CONV), 28, 0057, 88 }, + { OP(2, 1, 2, OP_CONV), 32, 0067, 96 }, + { OP(0, 0, 0, OP_JUMP_A), -13, 0, 0 }, +}; + +static dstatement_t bool64_conv_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 112 }, // index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 113 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 112, -2, 112 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 113, -4, 113 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, + { OP(1, 1, 2, OP_CONV), 0, 0107, 48 }, + { OP(1, 1, 2, OP_CONV), 4, 0117, 56 }, + { OP(1, 1, 2, OP_CONV), 8, 0127, 64 }, + { OP(2, 1, 2, OP_CONV), 16, 0137, 72 }, + { OP(1, 1, 2, OP_CONV), 24, 0147, 80 }, + { OP(1, 1, 2, OP_CONV), 28, 0157, 88 }, + { OP(2, 1, 2, OP_CONV), 32, 0167, 96 }, + { OP(0, 0, 0, OP_JUMP_A), -13, 0, 0 }, +}; + +static dstatement_t bool64_conv_3a_statements[] = { + { OP(1, 1, 2, OP_CONV), 0, 0207, 48 }, + { OP(1, 1, 2, OP_CONV), 3, 0007, 54 }, + { OP(1, 1, 2, OP_CONV), 4, 0217, 56 }, + { OP(1, 1, 2, OP_CONV), 7, 0017, 62 }, + { OP(1, 1, 2, OP_CONV), 8, 0227, 64 }, + { OP(1, 1, 2, OP_CONV), 14, 0027, 70 }, + { OP(2, 1, 2, OP_CONV), 16, 0237, 72 }, + { OP(2, 1, 2, OP_CONV), 22, 0037, 78 }, + { OP(1, 1, 2, OP_CONV), 24, 0247, 80 }, + { OP(1, 1, 2, OP_CONV), 27, 0047, 86 }, + { OP(1, 1, 2, OP_CONV), 28, 0257, 88 }, + { OP(1, 1, 2, OP_CONV), 31, 0057, 94 }, + { OP(2, 1, 2, OP_CONV), 32, 0267, 96 }, + { OP(2, 1, 2, OP_CONV), 38, 0067, 102 }, +}; + +static dstatement_t bool64_conv_3b_statements[] = { + { OP(1, 1, 2, OP_CONV), 0, 0007, 48 }, + { OP(1, 1, 2, OP_CONV), 1, 0207, 50 }, + { OP(1, 1, 2, OP_CONV), 4, 0017, 56 }, + { OP(1, 1, 2, OP_CONV), 5, 0217, 58 }, + { OP(1, 1, 2, OP_CONV), 8, 0027, 64 }, + { OP(1, 1, 2, OP_CONV), 10, 0227, 66 }, + { OP(2, 1, 2, OP_CONV), 16, 0037, 72 }, + { OP(2, 1, 2, OP_CONV), 18, 0237, 74 }, + { OP(1, 1, 2, OP_CONV), 24, 0047, 80 }, + { OP(1, 1, 2, OP_CONV), 25, 0247, 82 }, + { OP(1, 1, 2, OP_CONV), 28, 0057, 88 }, + { OP(1, 1, 2, OP_CONV), 29, 0257, 90 }, + { OP(2, 1, 2, OP_CONV), 32, 0067, 96 }, + { OP(2, 1, 2, OP_CONV), 34, 0267, 98 }, +}; + +static dstatement_t bool64_conv_4_statements[] = { + { OP(1, 1, 2, OP_CONV), 0, 0307, 48 }, + { OP(1, 1, 2, OP_CONV), 4, 0317, 56 }, + { OP(1, 1, 2, OP_CONV), 8, 0327, 64 }, + { OP(2, 1, 2, OP_CONV), 16, 0337, 72 }, + { OP(1, 1, 2, OP_CONV), 24, 0347, 80 }, + { OP(1, 1, 2, OP_CONV), 28, 0357, 88 }, + { OP(2, 1, 2, OP_CONV), 32, 0367, 96 }, +}; + +test_t tests[] = { + { + .desc = "bool64 conv 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(bool64_conv_init,bool64_conv_expect), + .num_statements = num_statements (bool64_conv_1_statements), + .statements = bool64_conv_1_statements, + .init_globals = (pr_int_t *) bool64_conv_init, + .expect_globals = (pr_int_t *) bool64_conv_expect, + }, + { + .desc = "bool64 conv 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(bool64_conv_init,bool64_conv_expect), + .num_statements = num_statements (bool64_conv_2_statements), + .statements = bool64_conv_2_statements, + .init_globals = (pr_int_t *) bool64_conv_init, + .expect_globals = (pr_int_t *) bool64_conv_expect, + }, + { + .desc = "bool64 conv 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(bool64_conv_init,bool64_conv_expect), + .num_statements = num_statements (bool64_conv_3a_statements), + .statements = bool64_conv_3a_statements, + .init_globals = (pr_int_t *) bool64_conv_init, + .expect_globals = (pr_int_t *) bool64_conv_expect, + }, + { + .desc = "bool64 conv 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(bool64_conv_init,bool64_conv_expect), + .num_statements = num_statements (bool64_conv_3b_statements), + .statements = bool64_conv_3b_statements, + .init_globals = (pr_int_t *) bool64_conv_init, + .expect_globals = (pr_int_t *) bool64_conv_expect, + }, + { + .desc = "bool64 conv 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(bool64_conv_init,bool64_conv_expect), + .num_statements = num_statements (bool64_conv_4_statements), + .statements = bool64_conv_4_statements, + .init_globals = (pr_int_t *) bool64_conv_init, + .expect_globals = (pr_int_t *) bool64_conv_expect, + }, +}; + +#include "main.c" From a1c1c9fcf0043048e6b53d4b0ab37100ec6537ad Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 14 Jan 2022 15:51:49 +0900 Subject: [PATCH 098/360] [gamecode] Add test for conversions to double And fix an incorrect base index in the bool64 tests. --- libs/gamecode/test/Makemodule.am | 6 + libs/gamecode/test/test-conv3.c | 199 +++++++++++++++++++++++++++++++ libs/gamecode/test/test-conv7.c | 14 +-- 3 files changed, 212 insertions(+), 7 deletions(-) create mode 100644 libs/gamecode/test/test-conv3.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index 560425a5e..a878155d1 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -2,6 +2,7 @@ libs_gamecode_tests = \ libs/gamecode/test/test-conv0 \ libs/gamecode/test/test-conv1 \ libs/gamecode/test/test-conv2 \ + libs/gamecode/test/test-conv3 \ libs/gamecode/test/test-conv4 \ libs/gamecode/test/test-conv5 \ libs/gamecode/test/test-conv6 \ @@ -41,6 +42,11 @@ libs_gamecode_test_test_conv2_SOURCES= \ libs_gamecode_test_test_conv2_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_conv2_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_conv3_SOURCES= \ + libs/gamecode/test/test-conv3.c +libs_gamecode_test_test_conv3_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_conv3_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_conv4_SOURCES= \ libs/gamecode/test/test-conv4.c libs_gamecode_test_test_conv4_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-conv3.c b/libs/gamecode/test/test-conv3.c new file mode 100644 index 000000000..e4fb1f03d --- /dev/null +++ b/libs/gamecode/test/test-conv3.c @@ -0,0 +1,199 @@ +#include "head.c" + +#include "QF/mathlib.h" + +static pr_ivec4_t double_conv_init[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float 1e30, -1e30 + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_ivec4_t double_conv_expect[] = { + { 5, -5, 0x80000000, 0x7fffffff}, //int + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, //float + { 99, 0x80000000, 0x80000000, 99}, //long + { 256, 0, 0x7fffffff, 0}, //long + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, //double 1e30, -1e30 + { 0, 0x3ff80000, 0, 0xbff80000}, //double 1.5, -1.5 + { 5, -5, 0x80000000, 0x7fffffff}, //uint + { ~0, 1, 0x80000000, 0}, //bool32 + { 99, 0x80000000, 0x80000000, 99}, //ulong + { 256, 0, 0x7fffffff, 0}, //ulong + { ~0, ~0, ~0, 0}, //bool64 + { 0, ~0, 0, 0}, //bool64 + { 0x00000000, 0x40140000, 0x00000000, 0xc0140000}, // int + { 0x00000000, 0xc1e00000, 0xffc00000, 0x41dfffff}, + { 0x00000000, 0x3ff80000, 0x00000000, 0xbff80000}, // float + { 0x40000000, 0x46293e59, 0x40000000, 0xc6293e59}, + { 0x00000000, 0xc3e00000, 0x00000000, 0x4258e000}, // long + { 0x00000000, 0x40700000, 0xffc00000, 0x41dfffff}, + { 0, 0, 0, 0}, // double + { 0, 0, 0, 0}, + { 0x00000000, 0x40140000, 0xff600000, 0x41efffff}, // uint + { 0x00000000, 0x41e00000, 0xffc00000, 0x41dfffff}, + { 0x00000000, 0x3ff00000, 0x00000000, 0x3ff00000}, // bool32 + { 0x00000000, 0x3ff00000, 0x00000000, 0x00000000}, + { 0x00000000, 0x43e00000, 0x00000000, 0x4258e000}, // long + { 0x00000000, 0x40700000, 0xffc00000, 0x41dfffff}, + { 0x00000000, 0x3ff00000, 0x00000000, 0x3ff00000}, // bool64 + { 0x00000000, 0x3ff00000, 0x00000000, 0x00000000}, +}; + +static dstatement_t double_conv_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 112 }, // init index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 113 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 112, -1, 112 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 113, -2, 113 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, + { OP(1, 1, 2, OP_CONV), 0, 0003, 48 }, + { OP(1, 1, 2, OP_CONV), 4, 0013, 56 }, + { OP(2, 1, 2, OP_CONV), 8, 0023, 64 }, + { OP(1, 1, 2, OP_CONV), 24, 0043, 80 }, + { OP(1, 1, 2, OP_CONV), 28, 0053, 88 }, + { OP(2, 1, 2, OP_CONV), 32, 0063, 96 }, + { OP(2, 1, 2, OP_CONV), 40, 0073, 104 }, + { OP(0, 0, 0, OP_JUMP_A), -13, 0, 0 }, +}; + +static dstatement_t double_conv_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 112 }, // index + { OP(0, 0, 0, OP_LEA_A), 8, 0, 113 }, // init index for 64-bits +//loop: + { OP(0, 0, 0, OP_LEA_C), 112, -2, 112 }, // dec index + { OP(0, 0, 0, OP_LEA_C), 113, -4, 113 }, // dec index for 64-bits + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, + { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, + { OP(1, 1, 2, OP_CONV), 0, 0103, 48 }, + { OP(1, 1, 2, OP_CONV), 4, 0113, 56 }, + { OP(2, 1, 2, OP_CONV), 8, 0123, 64 }, + { OP(1, 1, 2, OP_CONV), 24, 0143, 80 }, + { OP(1, 1, 2, OP_CONV), 28, 0153, 88 }, + { OP(2, 1, 2, OP_CONV), 32, 0163, 96 }, + { OP(2, 1, 2, OP_CONV), 40, 0173, 104 }, + { OP(0, 0, 0, OP_JUMP_A), -13, 0, 0 }, +}; + +static dstatement_t double_conv_3a_statements[] = { + { OP(1, 1, 2, OP_CONV), 0, 0203, 48 }, + { OP(1, 1, 2, OP_CONV), 3, 0003, 54 }, + { OP(1, 1, 2, OP_CONV), 4, 0213, 56 }, + { OP(1, 1, 2, OP_CONV), 7, 0013, 62 }, + { OP(2, 1, 2, OP_CONV), 8, 0223, 64 }, + { OP(2, 1, 2, OP_CONV), 14, 0023, 70 }, + { OP(1, 1, 2, OP_CONV), 24, 0243, 80 }, + { OP(1, 1, 2, OP_CONV), 27, 0043, 86 }, + { OP(1, 1, 2, OP_CONV), 28, 0253, 88 }, + { OP(1, 1, 2, OP_CONV), 31, 0053, 94 }, + { OP(2, 1, 2, OP_CONV), 32, 0263, 96 }, + { OP(2, 1, 2, OP_CONV), 38, 0063, 102 }, + { OP(2, 1, 2, OP_CONV), 40, 0273, 104 }, + { OP(2, 1, 2, OP_CONV), 46, 0073, 110 }, +}; + +static dstatement_t double_conv_3b_statements[] = { + { OP(1, 1, 2, OP_CONV), 0, 0003, 48 }, + { OP(1, 1, 2, OP_CONV), 1, 0203, 50 }, + { OP(1, 1, 2, OP_CONV), 4, 0013, 56 }, + { OP(1, 1, 2, OP_CONV), 5, 0213, 58 }, + { OP(2, 1, 2, OP_CONV), 8, 0023, 64 }, + { OP(2, 1, 2, OP_CONV), 10, 0223, 66 }, + { OP(1, 1, 2, OP_CONV), 24, 0043, 80 }, + { OP(1, 1, 2, OP_CONV), 25, 0243, 82 }, + { OP(1, 1, 2, OP_CONV), 28, 0053, 88 }, + { OP(1, 1, 2, OP_CONV), 29, 0253, 90 }, + { OP(2, 1, 2, OP_CONV), 32, 0063, 96 }, + { OP(2, 1, 2, OP_CONV), 34, 0263, 98 }, + { OP(2, 1, 2, OP_CONV), 40, 0073, 104 }, + { OP(2, 1, 2, OP_CONV), 42, 0273, 106 }, +}; + +static dstatement_t double_conv_4_statements[] = { + { OP(1, 1, 2, OP_CONV), 0, 0303, 48 }, + { OP(1, 1, 2, OP_CONV), 4, 0313, 56 }, + { OP(2, 1, 2, OP_CONV), 8, 0323, 64 }, + { OP(1, 1, 2, OP_CONV), 24, 0343, 80 }, + { OP(1, 1, 2, OP_CONV), 28, 0353, 88 }, + { OP(2, 1, 2, OP_CONV), 32, 0363, 96 }, + { OP(2, 1, 2, OP_CONV), 40, 0373, 104 }, +}; + +test_t tests[] = { + { + .desc = "double conv 1", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(double_conv_init,double_conv_expect), + .num_statements = num_statements (double_conv_1_statements), + .statements = double_conv_1_statements, + .init_globals = (pr_int_t *) double_conv_init, + .expect_globals = (pr_int_t *) double_conv_expect, + }, + { + .desc = "double conv 2", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(double_conv_init,double_conv_expect), + .num_statements = num_statements (double_conv_2_statements), + .statements = double_conv_2_statements, + .init_globals = (pr_int_t *) double_conv_init, + .expect_globals = (pr_int_t *) double_conv_expect, + }, + { + .desc = "double conv 3a", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(double_conv_init,double_conv_expect), + .num_statements = num_statements (double_conv_3a_statements), + .statements = double_conv_3a_statements, + .init_globals = (pr_int_t *) double_conv_init, + .expect_globals = (pr_int_t *) double_conv_expect, + }, + { + .desc = "double conv 3b", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(double_conv_init,double_conv_expect), + .num_statements = num_statements (double_conv_3b_statements), + .statements = double_conv_3b_statements, + .init_globals = (pr_int_t *) double_conv_init, + .expect_globals = (pr_int_t *) double_conv_expect, + }, + { + .desc = "double conv 4", + .extra_globals = 4 * 1, + .num_globals = 4*num_globals(double_conv_init,double_conv_expect), + .num_statements = num_statements (double_conv_4_statements), + .statements = double_conv_4_statements, + .init_globals = (pr_int_t *) double_conv_init, + .expect_globals = (pr_int_t *) double_conv_expect, + }, +}; + +#include "main.c" diff --git a/libs/gamecode/test/test-conv7.c b/libs/gamecode/test/test-conv7.c index 78e3a44df..1c6171db9 100644 --- a/libs/gamecode/test/test-conv7.c +++ b/libs/gamecode/test/test-conv7.c @@ -76,7 +76,7 @@ static dstatement_t bool64_conv_1_statements[] = { { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, { OP(1, 1, 2, OP_CONV), 0, 0007, 48 }, { OP(1, 1, 2, OP_CONV), 4, 0017, 56 }, - { OP(1, 1, 2, OP_CONV), 8, 0027, 64 }, + { OP(2, 1, 2, OP_CONV), 8, 0027, 64 }, { OP(2, 1, 2, OP_CONV), 16, 0037, 72 }, { OP(1, 1, 2, OP_CONV), 24, 0047, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0057, 88 }, @@ -96,7 +96,7 @@ static dstatement_t bool64_conv_2_statements[] = { { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, { OP(1, 1, 2, OP_CONV), 0, 0107, 48 }, { OP(1, 1, 2, OP_CONV), 4, 0117, 56 }, - { OP(1, 1, 2, OP_CONV), 8, 0127, 64 }, + { OP(2, 1, 2, OP_CONV), 8, 0127, 64 }, { OP(2, 1, 2, OP_CONV), 16, 0137, 72 }, { OP(1, 1, 2, OP_CONV), 24, 0147, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0157, 88 }, @@ -109,8 +109,8 @@ static dstatement_t bool64_conv_3a_statements[] = { { OP(1, 1, 2, OP_CONV), 3, 0007, 54 }, { OP(1, 1, 2, OP_CONV), 4, 0217, 56 }, { OP(1, 1, 2, OP_CONV), 7, 0017, 62 }, - { OP(1, 1, 2, OP_CONV), 8, 0227, 64 }, - { OP(1, 1, 2, OP_CONV), 14, 0027, 70 }, + { OP(2, 1, 2, OP_CONV), 8, 0227, 64 }, + { OP(2, 1, 2, OP_CONV), 14, 0027, 70 }, { OP(2, 1, 2, OP_CONV), 16, 0237, 72 }, { OP(2, 1, 2, OP_CONV), 22, 0037, 78 }, { OP(1, 1, 2, OP_CONV), 24, 0247, 80 }, @@ -126,8 +126,8 @@ static dstatement_t bool64_conv_3b_statements[] = { { OP(1, 1, 2, OP_CONV), 1, 0207, 50 }, { OP(1, 1, 2, OP_CONV), 4, 0017, 56 }, { OP(1, 1, 2, OP_CONV), 5, 0217, 58 }, - { OP(1, 1, 2, OP_CONV), 8, 0027, 64 }, - { OP(1, 1, 2, OP_CONV), 10, 0227, 66 }, + { OP(2, 1, 2, OP_CONV), 8, 0027, 64 }, + { OP(2, 1, 2, OP_CONV), 10, 0227, 66 }, { OP(2, 1, 2, OP_CONV), 16, 0037, 72 }, { OP(2, 1, 2, OP_CONV), 18, 0237, 74 }, { OP(1, 1, 2, OP_CONV), 24, 0047, 80 }, @@ -141,7 +141,7 @@ static dstatement_t bool64_conv_3b_statements[] = { static dstatement_t bool64_conv_4_statements[] = { { OP(1, 1, 2, OP_CONV), 0, 0307, 48 }, { OP(1, 1, 2, OP_CONV), 4, 0317, 56 }, - { OP(1, 1, 2, OP_CONV), 8, 0327, 64 }, + { OP(2, 1, 2, OP_CONV), 8, 0327, 64 }, { OP(2, 1, 2, OP_CONV), 16, 0337, 72 }, { OP(1, 1, 2, OP_CONV), 24, 0347, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0357, 88 }, From a81067603cde72701569d42c48efe3cda1e0594a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 14 Jan 2022 16:52:44 +0900 Subject: [PATCH 099/360] [gamecode] Mention possibly undefined behavior It seems casting from float/double to [unsigned] int/long when the value doesn't fit is undefined (which would explain the inconsistent results). Mentioning the possibility seems like a good idea should the results for such casts change and cause the tests to fail. --- libs/gamecode/test/test-conv0.c | 4 ++-- libs/gamecode/test/test-conv2.c | 4 ++-- libs/gamecode/test/test-conv4.c | 6 ++---- libs/gamecode/test/test-conv6.c | 4 ++-- 4 files changed, 8 insertions(+), 10 deletions(-) diff --git a/libs/gamecode/test/test-conv0.c b/libs/gamecode/test/test-conv0.c index e6d6b6ad7..f8b0e7b03 100644 --- a/libs/gamecode/test/test-conv0.c +++ b/libs/gamecode/test/test-conv0.c @@ -39,9 +39,9 @@ static pr_ivec4_t int_conv_expect[] = { { ~0, ~0, ~0, 0}, //bool64 { 0, ~0, 0, 0}, //bool64 { 0, 0, 0, 0}, // int - { 1, -1, 0x80000000, 0x80000000}, // float + { 1, -1, 0x80000000, 0x80000000}, // float undef? { 99, 0x80000000, 256, 0x7fffffff}, // long - { 0x80000000, 0x80000000, 1, -1}, // double + { 0x80000000, 0x80000000, 1, -1}, // double undef? { 0, 0, 0, 0}, // uint { 1, 1, 1, 0}, // bool32 { 99, 0x80000000, 256, 0x7fffffff}, // ulong diff --git a/libs/gamecode/test/test-conv2.c b/libs/gamecode/test/test-conv2.c index 654dd4c90..ee87f7531 100644 --- a/libs/gamecode/test/test-conv2.c +++ b/libs/gamecode/test/test-conv2.c @@ -49,10 +49,10 @@ static pr_ivec4_t long_conv_expect[] = { { 5, 0, -5, 0xffffffff}, // int { 0x80000000, 0xffffffff, 0x7fffffff, 0}, { 1, 0, -1, -1}, // float - { 0, 0x80000000, 0, 0x80000000}, + { 0, 0x80000000, 0, 0x80000000}, // undef? { 0, 0, 0, 0}, // long { 0, 0, 0, 0}, - { 0, 0x80000000, 0, 0x80000000}, // double + { 0, 0x80000000, 0, 0x80000000}, // double undef? { 1, 0, -1, -1}, { 5, 0, -5, 0}, // uint { 0x80000000, 0, 0x7fffffff, 0}, diff --git a/libs/gamecode/test/test-conv4.c b/libs/gamecode/test/test-conv4.c index 4accd2ee8..8fc1ec846 100644 --- a/libs/gamecode/test/test-conv4.c +++ b/libs/gamecode/test/test-conv4.c @@ -39,11 +39,9 @@ static pr_ivec4_t uint_conv_expect[] = { { ~0, ~0, ~0, 0}, //bool64 { 0, ~0, 0, 0}, //bool64 { 0, 0, 0, 0}, // int - // why 0? expected 0xfffffff. vv gcc bug? - { 1, 0xffffffff, 0, 0}, // float + { 1, 0xffffffff, 0, 0}, // float undef? { 99, 0x80000000, 256, 0x7fffffff}, // long - // why 0? vv expected 0xfffffff. gcc bug? - { 0, 0, 1, 0xffffffff}, // double + { 0, 0, 1, 0xffffffff}, // double undef? { 0, 0, 0, 0}, // uint { 1, 1, 1, 0}, // bool32 { 99, 0x80000000, 256, 0x7fffffff}, // ulong diff --git a/libs/gamecode/test/test-conv6.c b/libs/gamecode/test/test-conv6.c index a5d4f7881..3e84eeb03 100644 --- a/libs/gamecode/test/test-conv6.c +++ b/libs/gamecode/test/test-conv6.c @@ -49,10 +49,10 @@ static pr_ivec4_t ulong_conv_expect[] = { { 5, 0, -5, 0xffffffff}, // int { 0x80000000, 0xffffffff, 0x7fffffff, 0}, { 1, 0, -1, -1}, // float - { 0, 0, 0, 0x80000000}, + { 0, 0, 0, 0x80000000}, // undef? { 0, 0, 0, 0}, // long { 0, 0, 0, 0}, - { 0, 0, 0, 0x80000000}, // double + { 0, 0, 0, 0x80000000}, // double undef? { 1, 0, -1, -1}, { 5, 0, -5, 0}, // uint { 0x80000000, 0, 0x7fffffff, 0}, From 1a2ac24d8db1a0e23478ac8fc313824e9e5cbe19 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 14 Jan 2022 19:43:34 +0900 Subject: [PATCH 100/360] [gamecode] Make num_globals() calculate actual globals It calculating only the size of the array (which was often 4 or 8 globals per element) proved to be a pain when I forgot to alter the size for the new scale tests. Fixing the size calculation even found a bug in the shiftop tests. --- libs/gamecode/test/head.c | 4 ++- libs/gamecode/test/test-conv0.c | 10 +++---- libs/gamecode/test/test-conv1.c | 10 +++---- libs/gamecode/test/test-conv2.c | 10 +++---- libs/gamecode/test/test-conv3.c | 10 +++---- libs/gamecode/test/test-conv4.c | 10 +++---- libs/gamecode/test/test-conv5.c | 10 +++---- libs/gamecode/test/test-conv6.c | 10 +++---- libs/gamecode/test/test-conv7.c | 10 +++---- libs/gamecode/test/test-double.c | 22 ++++++++-------- libs/gamecode/test/test-float.c | 22 ++++++++-------- libs/gamecode/test/test-int.c | 20 +++++++------- libs/gamecode/test/test-long.c | 20 +++++++------- libs/gamecode/test/test-unsigned.c | 42 +++++++++++++++--------------- libs/gamecode/test/test-vector.c | 4 +-- 15 files changed, 108 insertions(+), 106 deletions(-) diff --git a/libs/gamecode/test/head.c b/libs/gamecode/test/head.c index c7db8fb26..36985c821 100644 --- a/libs/gamecode/test/head.c +++ b/libs/gamecode/test/head.c @@ -11,7 +11,9 @@ static int verbose = 0; // error if the sizes differ) #define num_globals(init, expect) \ __builtin_choose_expr ( \ - sizeof (init) == sizeof (expect), sizeof (init) / sizeof (init[0]), \ + sizeof (init) == sizeof (expect), \ + (sizeof (init) / sizeof (init[0])) \ + * (sizeof (init[0]) / sizeof (pr_type_t)), \ (void) 0\ ) diff --git a/libs/gamecode/test/test-conv0.c b/libs/gamecode/test/test-conv0.c index f8b0e7b03..bfa492225 100644 --- a/libs/gamecode/test/test-conv0.c +++ b/libs/gamecode/test/test-conv0.c @@ -129,7 +129,7 @@ test_t tests[] = { { .desc = "int conv 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_conv_init,int_conv_expect), + .num_globals = num_globals(int_conv_init,int_conv_expect), .num_statements = num_statements (int_conv_1_statements), .statements = int_conv_1_statements, .init_globals = (pr_int_t *) int_conv_init, @@ -138,7 +138,7 @@ test_t tests[] = { { .desc = "int conv 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_conv_init,int_conv_expect), + .num_globals = num_globals(int_conv_init,int_conv_expect), .num_statements = num_statements (int_conv_2_statements), .statements = int_conv_2_statements, .init_globals = (pr_int_t *) int_conv_init, @@ -147,7 +147,7 @@ test_t tests[] = { { .desc = "int conv 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_conv_init,int_conv_expect), + .num_globals = num_globals(int_conv_init,int_conv_expect), .num_statements = num_statements (int_conv_3a_statements), .statements = int_conv_3a_statements, .init_globals = (pr_int_t *) int_conv_init, @@ -156,7 +156,7 @@ test_t tests[] = { { .desc = "int conv 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_conv_init,int_conv_expect), + .num_globals = num_globals(int_conv_init,int_conv_expect), .num_statements = num_statements (int_conv_3b_statements), .statements = int_conv_3b_statements, .init_globals = (pr_int_t *) int_conv_init, @@ -165,7 +165,7 @@ test_t tests[] = { { .desc = "int conv 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_conv_init,int_conv_expect), + .num_globals = num_globals(int_conv_init,int_conv_expect), .num_statements = num_statements (int_conv_4_statements), .statements = int_conv_4_statements, .init_globals = (pr_int_t *) int_conv_init, diff --git a/libs/gamecode/test/test-conv1.c b/libs/gamecode/test/test-conv1.c index 541aa6788..97c9735fe 100644 --- a/libs/gamecode/test/test-conv1.c +++ b/libs/gamecode/test/test-conv1.c @@ -136,7 +136,7 @@ test_t tests[] = { { .desc = "float conv 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_conv_init,float_conv_expect), + .num_globals = num_globals(float_conv_init,float_conv_expect), .num_statements = num_statements (float_conv_1_statements), .statements = float_conv_1_statements, .init_globals = (pr_int_t *) float_conv_init, @@ -145,7 +145,7 @@ test_t tests[] = { { .desc = "float conv 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_conv_init,float_conv_expect), + .num_globals = num_globals(float_conv_init,float_conv_expect), .num_statements = num_statements (float_conv_2_statements), .statements = float_conv_2_statements, .init_globals = (pr_int_t *) float_conv_init, @@ -154,7 +154,7 @@ test_t tests[] = { { .desc = "float conv 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_conv_init,float_conv_expect), + .num_globals = num_globals(float_conv_init,float_conv_expect), .num_statements = num_statements (float_conv_3a_statements), .statements = float_conv_3a_statements, .init_globals = (pr_int_t *) float_conv_init, @@ -163,7 +163,7 @@ test_t tests[] = { { .desc = "float conv 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_conv_init,float_conv_expect), + .num_globals = num_globals(float_conv_init,float_conv_expect), .num_statements = num_statements (float_conv_3b_statements), .statements = float_conv_3b_statements, .init_globals = (pr_int_t *) float_conv_init, @@ -172,7 +172,7 @@ test_t tests[] = { { .desc = "float conv 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_conv_init,float_conv_expect), + .num_globals = num_globals(float_conv_init,float_conv_expect), .num_statements = num_statements (float_conv_4_statements), .statements = float_conv_4_statements, .init_globals = (pr_int_t *) float_conv_init, diff --git a/libs/gamecode/test/test-conv2.c b/libs/gamecode/test/test-conv2.c index ee87f7531..668f00724 100644 --- a/libs/gamecode/test/test-conv2.c +++ b/libs/gamecode/test/test-conv2.c @@ -145,7 +145,7 @@ test_t tests[] = { { .desc = "long conv 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(long_conv_init,long_conv_expect), + .num_globals = num_globals(long_conv_init,long_conv_expect), .num_statements = num_statements (long_conv_1_statements), .statements = long_conv_1_statements, .init_globals = (pr_int_t *) long_conv_init, @@ -154,7 +154,7 @@ test_t tests[] = { { .desc = "long conv 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(long_conv_init,long_conv_expect), + .num_globals = num_globals(long_conv_init,long_conv_expect), .num_statements = num_statements (long_conv_2_statements), .statements = long_conv_2_statements, .init_globals = (pr_int_t *) long_conv_init, @@ -163,7 +163,7 @@ test_t tests[] = { { .desc = "long conv 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(long_conv_init,long_conv_expect), + .num_globals = num_globals(long_conv_init,long_conv_expect), .num_statements = num_statements (long_conv_3a_statements), .statements = long_conv_3a_statements, .init_globals = (pr_int_t *) long_conv_init, @@ -172,7 +172,7 @@ test_t tests[] = { { .desc = "long conv 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(long_conv_init,long_conv_expect), + .num_globals = num_globals(long_conv_init,long_conv_expect), .num_statements = num_statements (long_conv_3b_statements), .statements = long_conv_3b_statements, .init_globals = (pr_int_t *) long_conv_init, @@ -181,7 +181,7 @@ test_t tests[] = { { .desc = "long conv 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(long_conv_init,long_conv_expect), + .num_globals = num_globals(long_conv_init,long_conv_expect), .num_statements = num_statements (long_conv_4_statements), .statements = long_conv_4_statements, .init_globals = (pr_int_t *) long_conv_init, diff --git a/libs/gamecode/test/test-conv3.c b/libs/gamecode/test/test-conv3.c index e4fb1f03d..038b20689 100644 --- a/libs/gamecode/test/test-conv3.c +++ b/libs/gamecode/test/test-conv3.c @@ -152,7 +152,7 @@ test_t tests[] = { { .desc = "double conv 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(double_conv_init,double_conv_expect), + .num_globals = num_globals(double_conv_init,double_conv_expect), .num_statements = num_statements (double_conv_1_statements), .statements = double_conv_1_statements, .init_globals = (pr_int_t *) double_conv_init, @@ -161,7 +161,7 @@ test_t tests[] = { { .desc = "double conv 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(double_conv_init,double_conv_expect), + .num_globals = num_globals(double_conv_init,double_conv_expect), .num_statements = num_statements (double_conv_2_statements), .statements = double_conv_2_statements, .init_globals = (pr_int_t *) double_conv_init, @@ -170,7 +170,7 @@ test_t tests[] = { { .desc = "double conv 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(double_conv_init,double_conv_expect), + .num_globals = num_globals(double_conv_init,double_conv_expect), .num_statements = num_statements (double_conv_3a_statements), .statements = double_conv_3a_statements, .init_globals = (pr_int_t *) double_conv_init, @@ -179,7 +179,7 @@ test_t tests[] = { { .desc = "double conv 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(double_conv_init,double_conv_expect), + .num_globals = num_globals(double_conv_init,double_conv_expect), .num_statements = num_statements (double_conv_3b_statements), .statements = double_conv_3b_statements, .init_globals = (pr_int_t *) double_conv_init, @@ -188,7 +188,7 @@ test_t tests[] = { { .desc = "double conv 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(double_conv_init,double_conv_expect), + .num_globals = num_globals(double_conv_init,double_conv_expect), .num_statements = num_statements (double_conv_4_statements), .statements = double_conv_4_statements, .init_globals = (pr_int_t *) double_conv_init, diff --git a/libs/gamecode/test/test-conv4.c b/libs/gamecode/test/test-conv4.c index 8fc1ec846..28f151339 100644 --- a/libs/gamecode/test/test-conv4.c +++ b/libs/gamecode/test/test-conv4.c @@ -129,7 +129,7 @@ test_t tests[] = { { .desc = "uint conv 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_conv_init,uint_conv_expect), + .num_globals = num_globals(uint_conv_init,uint_conv_expect), .num_statements = num_statements (uint_conv_1_statements), .statements = uint_conv_1_statements, .init_globals = (pr_int_t *) uint_conv_init, @@ -138,7 +138,7 @@ test_t tests[] = { { .desc = "uint conv 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_conv_init,uint_conv_expect), + .num_globals = num_globals(uint_conv_init,uint_conv_expect), .num_statements = num_statements (uint_conv_2_statements), .statements = uint_conv_2_statements, .init_globals = (pr_int_t *) uint_conv_init, @@ -147,7 +147,7 @@ test_t tests[] = { { .desc = "uint conv 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_conv_init,uint_conv_expect), + .num_globals = num_globals(uint_conv_init,uint_conv_expect), .num_statements = num_statements (uint_conv_3a_statements), .statements = uint_conv_3a_statements, .init_globals = (pr_int_t *) uint_conv_init, @@ -156,7 +156,7 @@ test_t tests[] = { { .desc = "uint conv 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_conv_init,uint_conv_expect), + .num_globals = num_globals(uint_conv_init,uint_conv_expect), .num_statements = num_statements (uint_conv_3b_statements), .statements = uint_conv_3b_statements, .init_globals = (pr_int_t *) uint_conv_init, @@ -165,7 +165,7 @@ test_t tests[] = { { .desc = "uint conv 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_conv_init,uint_conv_expect), + .num_globals = num_globals(uint_conv_init,uint_conv_expect), .num_statements = num_statements (uint_conv_4_statements), .statements = uint_conv_4_statements, .init_globals = (pr_int_t *) uint_conv_init, diff --git a/libs/gamecode/test/test-conv5.c b/libs/gamecode/test/test-conv5.c index 2a1d92a46..796bd9cf6 100644 --- a/libs/gamecode/test/test-conv5.c +++ b/libs/gamecode/test/test-conv5.c @@ -136,7 +136,7 @@ test_t tests[] = { { .desc = "bool32 conv 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(bool32_conv_init,bool32_conv_expect), + .num_globals = num_globals(bool32_conv_init,bool32_conv_expect), .num_statements = num_statements (bool32_conv_1_statements), .statements = bool32_conv_1_statements, .init_globals = (pr_int_t *) bool32_conv_init, @@ -145,7 +145,7 @@ test_t tests[] = { { .desc = "bool32 conv 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(bool32_conv_init,bool32_conv_expect), + .num_globals = num_globals(bool32_conv_init,bool32_conv_expect), .num_statements = num_statements (bool32_conv_2_statements), .statements = bool32_conv_2_statements, .init_globals = (pr_int_t *) bool32_conv_init, @@ -154,7 +154,7 @@ test_t tests[] = { { .desc = "bool32 conv 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(bool32_conv_init,bool32_conv_expect), + .num_globals = num_globals(bool32_conv_init,bool32_conv_expect), .num_statements = num_statements (bool32_conv_3a_statements), .statements = bool32_conv_3a_statements, .init_globals = (pr_int_t *) bool32_conv_init, @@ -163,7 +163,7 @@ test_t tests[] = { { .desc = "bool32 conv 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(bool32_conv_init,bool32_conv_expect), + .num_globals = num_globals(bool32_conv_init,bool32_conv_expect), .num_statements = num_statements (bool32_conv_3b_statements), .statements = bool32_conv_3b_statements, .init_globals = (pr_int_t *) bool32_conv_init, @@ -172,7 +172,7 @@ test_t tests[] = { { .desc = "bool32 conv 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(bool32_conv_init,bool32_conv_expect), + .num_globals = num_globals(bool32_conv_init,bool32_conv_expect), .num_statements = num_statements (bool32_conv_4_statements), .statements = bool32_conv_4_statements, .init_globals = (pr_int_t *) bool32_conv_init, diff --git a/libs/gamecode/test/test-conv6.c b/libs/gamecode/test/test-conv6.c index 3e84eeb03..58bafe43c 100644 --- a/libs/gamecode/test/test-conv6.c +++ b/libs/gamecode/test/test-conv6.c @@ -145,7 +145,7 @@ test_t tests[] = { { .desc = "ulong conv 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_conv_init,ulong_conv_expect), + .num_globals = num_globals(ulong_conv_init,ulong_conv_expect), .num_statements = num_statements (ulong_conv_1_statements), .statements = ulong_conv_1_statements, .init_globals = (pr_int_t *) ulong_conv_init, @@ -154,7 +154,7 @@ test_t tests[] = { { .desc = "ulong conv 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_conv_init,ulong_conv_expect), + .num_globals = num_globals(ulong_conv_init,ulong_conv_expect), .num_statements = num_statements (ulong_conv_2_statements), .statements = ulong_conv_2_statements, .init_globals = (pr_int_t *) ulong_conv_init, @@ -163,7 +163,7 @@ test_t tests[] = { { .desc = "ulong conv 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_conv_init,ulong_conv_expect), + .num_globals = num_globals(ulong_conv_init,ulong_conv_expect), .num_statements = num_statements (ulong_conv_3a_statements), .statements = ulong_conv_3a_statements, .init_globals = (pr_int_t *) ulong_conv_init, @@ -172,7 +172,7 @@ test_t tests[] = { { .desc = "ulong conv 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_conv_init,ulong_conv_expect), + .num_globals = num_globals(ulong_conv_init,ulong_conv_expect), .num_statements = num_statements (ulong_conv_3b_statements), .statements = ulong_conv_3b_statements, .init_globals = (pr_int_t *) ulong_conv_init, @@ -181,7 +181,7 @@ test_t tests[] = { { .desc = "ulong conv 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_conv_init,ulong_conv_expect), + .num_globals = num_globals(ulong_conv_init,ulong_conv_expect), .num_statements = num_statements (ulong_conv_4_statements), .statements = ulong_conv_4_statements, .init_globals = (pr_int_t *) ulong_conv_init, diff --git a/libs/gamecode/test/test-conv7.c b/libs/gamecode/test/test-conv7.c index 1c6171db9..9612b1ee0 100644 --- a/libs/gamecode/test/test-conv7.c +++ b/libs/gamecode/test/test-conv7.c @@ -152,7 +152,7 @@ test_t tests[] = { { .desc = "bool64 conv 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(bool64_conv_init,bool64_conv_expect), + .num_globals = num_globals(bool64_conv_init,bool64_conv_expect), .num_statements = num_statements (bool64_conv_1_statements), .statements = bool64_conv_1_statements, .init_globals = (pr_int_t *) bool64_conv_init, @@ -161,7 +161,7 @@ test_t tests[] = { { .desc = "bool64 conv 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(bool64_conv_init,bool64_conv_expect), + .num_globals = num_globals(bool64_conv_init,bool64_conv_expect), .num_statements = num_statements (bool64_conv_2_statements), .statements = bool64_conv_2_statements, .init_globals = (pr_int_t *) bool64_conv_init, @@ -170,7 +170,7 @@ test_t tests[] = { { .desc = "bool64 conv 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(bool64_conv_init,bool64_conv_expect), + .num_globals = num_globals(bool64_conv_init,bool64_conv_expect), .num_statements = num_statements (bool64_conv_3a_statements), .statements = bool64_conv_3a_statements, .init_globals = (pr_int_t *) bool64_conv_init, @@ -179,7 +179,7 @@ test_t tests[] = { { .desc = "bool64 conv 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(bool64_conv_init,bool64_conv_expect), + .num_globals = num_globals(bool64_conv_init,bool64_conv_expect), .num_statements = num_statements (bool64_conv_3b_statements), .statements = bool64_conv_3b_statements, .init_globals = (pr_int_t *) bool64_conv_init, @@ -188,7 +188,7 @@ test_t tests[] = { { .desc = "bool64 conv 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(bool64_conv_init,bool64_conv_expect), + .num_globals = num_globals(bool64_conv_init,bool64_conv_expect), .num_statements = num_statements (bool64_conv_4_statements), .statements = bool64_conv_4_statements, .init_globals = (pr_int_t *) bool64_conv_init, diff --git a/libs/gamecode/test/test-double.c b/libs/gamecode/test/test-double.c index 317e18df4..239630034 100644 --- a/libs/gamecode/test/test-double.c +++ b/libs/gamecode/test/test-double.c @@ -232,7 +232,7 @@ test_t tests[] = { { .desc = "double binop 1", .extra_globals = 8 * 1, - .num_globals = 8*num_globals(double_binop_init,double_binop_expect), + .num_globals = num_globals(double_binop_init,double_binop_expect), .num_statements = num_statements (double_binop_1_statements), .statements = double_binop_1_statements, .init_globals = (pr_int_t *) double_binop_init, @@ -241,7 +241,7 @@ test_t tests[] = { { .desc = "double binop 2", .extra_globals = 8 * 1, - .num_globals = 8*num_globals(double_binop_init,double_binop_expect), + .num_globals = num_globals(double_binop_init,double_binop_expect), .num_statements = num_statements (double_binop_2_statements), .statements = double_binop_2_statements, .init_globals = (pr_int_t *) double_binop_init, @@ -250,7 +250,7 @@ test_t tests[] = { { .desc = "double binop 3a", .extra_globals = 8 * 1, - .num_globals = 8*num_globals(double_binop_init,double_binop_expect), + .num_globals = num_globals(double_binop_init,double_binop_expect), .num_statements = num_statements (double_binop_3a_statements), .statements = double_binop_3a_statements, .init_globals = (pr_int_t *) double_binop_init, @@ -259,7 +259,7 @@ test_t tests[] = { { .desc = "double binop 3b", .extra_globals = 8 * 1, - .num_globals = 8*num_globals(double_binop_init,double_binop_expect), + .num_globals = num_globals(double_binop_init,double_binop_expect), .num_statements = num_statements (double_binop_3b_statements), .statements = double_binop_3b_statements, .init_globals = (pr_int_t *) double_binop_init, @@ -268,7 +268,7 @@ test_t tests[] = { { .desc = "double binop 4", .extra_globals = 8 * 1, - .num_globals = 8*num_globals(double_binop_init,double_binop_expect), + .num_globals = num_globals(double_binop_init,double_binop_expect), .num_statements = num_statements (double_binop_4_statements), .statements = double_binop_4_statements, .init_globals = (pr_int_t *) double_binop_init, @@ -277,7 +277,7 @@ test_t tests[] = { { .desc = "double cos sin", .extra_globals = 8 * 1, - .num_globals = 8*num_globals(double_cossin_init,double_cossin_expect), + .num_globals = num_globals(double_cossin_init,double_cossin_expect), .num_statements = num_statements (double_cossin_statements), .statements = double_cossin_statements, .init_globals = (pr_int_t *) double_cossin_init, @@ -286,7 +286,7 @@ test_t tests[] = { { .desc = "double cmpop 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(double_cmpop_init,double_cmpop_expect), + .num_globals = num_globals(double_cmpop_init,double_cmpop_expect), .num_statements = num_statements (double_cmpop_1_statements), .statements = double_cmpop_1_statements, .init_globals = (pr_int_t *) double_cmpop_init, @@ -295,7 +295,7 @@ test_t tests[] = { { .desc = "double cmpop 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(double_cmpop_init,double_cmpop_expect), + .num_globals = num_globals(double_cmpop_init,double_cmpop_expect), .num_statements = num_statements (double_cmpop_2_statements), .statements = double_cmpop_2_statements, .init_globals = (pr_int_t *) double_cmpop_init, @@ -304,7 +304,7 @@ test_t tests[] = { { .desc = "double cmpop 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(double_cmpop_init,double_cmpop_expect), + .num_globals = num_globals(double_cmpop_init,double_cmpop_expect), .num_statements = num_statements (double_cmpop_3a_statements), .statements = double_cmpop_3a_statements, .init_globals = (pr_int_t *) double_cmpop_init, @@ -313,7 +313,7 @@ test_t tests[] = { { .desc = "double cmpop 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(double_cmpop_init,double_cmpop_expect), + .num_globals = num_globals(double_cmpop_init,double_cmpop_expect), .num_statements = num_statements (double_cmpop_3b_statements), .statements = double_cmpop_3b_statements, .init_globals = (pr_int_t *) double_cmpop_init, @@ -322,7 +322,7 @@ test_t tests[] = { { .desc = "double cmpop 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(double_cmpop_init,double_cmpop_expect), + .num_globals = num_globals(double_cmpop_init,double_cmpop_expect), .num_statements = num_statements (double_cmpop_4_statements), .statements = double_cmpop_4_statements, .init_globals = (pr_int_t *) double_cmpop_init, diff --git a/libs/gamecode/test/test-float.c b/libs/gamecode/test/test-float.c index d01e90518..626f4aaa0 100644 --- a/libs/gamecode/test/test-float.c +++ b/libs/gamecode/test/test-float.c @@ -232,7 +232,7 @@ test_t tests[] = { { .desc = "float binop 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_binop_init,float_binop_expect), + .num_globals = num_globals(float_binop_init,float_binop_expect), .num_statements = num_statements (float_binop_1_statements), .statements = float_binop_1_statements, .init_globals = (pr_int_t *) float_binop_init, @@ -241,7 +241,7 @@ test_t tests[] = { { .desc = "float binop 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_binop_init,float_binop_expect), + .num_globals = num_globals(float_binop_init,float_binop_expect), .num_statements = num_statements (float_binop_2_statements), .statements = float_binop_2_statements, .init_globals = (pr_int_t *) float_binop_init, @@ -250,7 +250,7 @@ test_t tests[] = { { .desc = "float binop 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_binop_init,float_binop_expect), + .num_globals = num_globals(float_binop_init,float_binop_expect), .num_statements = num_statements (float_binop_3a_statements), .statements = float_binop_3a_statements, .init_globals = (pr_int_t *) float_binop_init, @@ -259,7 +259,7 @@ test_t tests[] = { { .desc = "float binop 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_binop_init,float_binop_expect), + .num_globals = num_globals(float_binop_init,float_binop_expect), .num_statements = num_statements (float_binop_3b_statements), .statements = float_binop_3b_statements, .init_globals = (pr_int_t *) float_binop_init, @@ -268,7 +268,7 @@ test_t tests[] = { { .desc = "float binop 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_binop_init,float_binop_expect), + .num_globals = num_globals(float_binop_init,float_binop_expect), .num_statements = num_statements (float_binop_4_statements), .statements = float_binop_4_statements, .init_globals = (pr_int_t *) float_binop_init, @@ -277,7 +277,7 @@ test_t tests[] = { { .desc = "float cos sin", .extra_globals = 4 * 1, - .num_globals = 4 * num_globals (float_cossin_init, float_cossin_expect), + .num_globals = num_globals (float_cossin_init, float_cossin_expect), .num_statements = num_statements (float_cossin_statements), .statements = float_cossin_statements, .init_globals = (pr_int_t *) float_cossin_init, @@ -286,7 +286,7 @@ test_t tests[] = { { .desc = "float cmpop 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_cmpop_init,float_cmpop_expect), + .num_globals = num_globals(float_cmpop_init,float_cmpop_expect), .num_statements = num_statements (float_cmpop_1_statements), .statements = float_cmpop_1_statements, .init_globals = (pr_int_t *) float_cmpop_init, @@ -295,7 +295,7 @@ test_t tests[] = { { .desc = "float cmpop 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_cmpop_init,float_cmpop_expect), + .num_globals = num_globals(float_cmpop_init,float_cmpop_expect), .num_statements = num_statements (float_cmpop_2_statements), .statements = float_cmpop_2_statements, .init_globals = (pr_int_t *) float_cmpop_init, @@ -304,7 +304,7 @@ test_t tests[] = { { .desc = "float cmpop 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_cmpop_init,float_cmpop_expect), + .num_globals = num_globals(float_cmpop_init,float_cmpop_expect), .num_statements = num_statements (float_cmpop_3a_statements), .statements = float_cmpop_3a_statements, .init_globals = (pr_int_t *) float_cmpop_init, @@ -313,7 +313,7 @@ test_t tests[] = { { .desc = "float cmpop 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_cmpop_init,float_cmpop_expect), + .num_globals = num_globals(float_cmpop_init,float_cmpop_expect), .num_statements = num_statements (float_cmpop_3b_statements), .statements = float_cmpop_3b_statements, .init_globals = (pr_int_t *) float_cmpop_init, @@ -322,7 +322,7 @@ test_t tests[] = { { .desc = "float cmpop 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(float_cmpop_init,float_cmpop_expect), + .num_globals = num_globals(float_cmpop_init,float_cmpop_expect), .num_statements = num_statements (float_cmpop_4_statements), .statements = float_cmpop_4_statements, .init_globals = (pr_int_t *) float_cmpop_init, diff --git a/libs/gamecode/test/test-int.c b/libs/gamecode/test/test-int.c index fd5d25af8..f8b4a6a5e 100644 --- a/libs/gamecode/test/test-int.c +++ b/libs/gamecode/test/test-int.c @@ -192,7 +192,7 @@ test_t tests[] = { { .desc = "int binop 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_binop_init,int_binop_expect), + .num_globals = num_globals(int_binop_init,int_binop_expect), .num_statements = num_statements (int_binop_1_statements), .statements = int_binop_1_statements, .init_globals = (pr_int_t *) int_binop_init, @@ -201,7 +201,7 @@ test_t tests[] = { { .desc = "int binop 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_binop_init,int_binop_expect), + .num_globals = num_globals(int_binop_init,int_binop_expect), .num_statements = num_statements (int_binop_2_statements), .statements = int_binop_2_statements, .init_globals = (pr_int_t *) int_binop_init, @@ -210,7 +210,7 @@ test_t tests[] = { { .desc = "int binop 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_binop_init,int_binop_expect), + .num_globals = num_globals(int_binop_init,int_binop_expect), .num_statements = num_statements (int_binop_3a_statements), .statements = int_binop_3a_statements, .init_globals = (pr_int_t *) int_binop_init, @@ -219,7 +219,7 @@ test_t tests[] = { { .desc = "int binop 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_binop_init,int_binop_expect), + .num_globals = num_globals(int_binop_init,int_binop_expect), .num_statements = num_statements (int_binop_3b_statements), .statements = int_binop_3b_statements, .init_globals = (pr_int_t *) int_binop_init, @@ -228,7 +228,7 @@ test_t tests[] = { { .desc = "int binop 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_binop_init,int_binop_expect), + .num_globals = num_globals(int_binop_init,int_binop_expect), .num_statements = num_statements (int_binop_4_statements), .statements = int_binop_4_statements, .init_globals = (pr_int_t *) int_binop_init, @@ -237,7 +237,7 @@ test_t tests[] = { { .desc = "int cmpop 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_cmpop_init,int_cmpop_expect), + .num_globals = num_globals(int_cmpop_init,int_cmpop_expect), .num_statements = num_statements (int_cmpop_1_statements), .statements = int_cmpop_1_statements, .init_globals = (pr_int_t *) int_cmpop_init, @@ -246,7 +246,7 @@ test_t tests[] = { { .desc = "int cmpop 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_cmpop_init,int_cmpop_expect), + .num_globals = num_globals(int_cmpop_init,int_cmpop_expect), .num_statements = num_statements (int_cmpop_2_statements), .statements = int_cmpop_2_statements, .init_globals = (pr_int_t *) int_cmpop_init, @@ -255,7 +255,7 @@ test_t tests[] = { { .desc = "int cmpop 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_cmpop_init,int_cmpop_expect), + .num_globals = num_globals(int_cmpop_init,int_cmpop_expect), .num_statements = num_statements (int_cmpop_3a_statements), .statements = int_cmpop_3a_statements, .init_globals = (pr_int_t *) int_cmpop_init, @@ -264,7 +264,7 @@ test_t tests[] = { { .desc = "int cmpop 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_cmpop_init,int_cmpop_expect), + .num_globals = num_globals(int_cmpop_init,int_cmpop_expect), .num_statements = num_statements (int_cmpop_3b_statements), .statements = int_cmpop_3b_statements, .init_globals = (pr_int_t *) int_cmpop_init, @@ -273,7 +273,7 @@ test_t tests[] = { { .desc = "int cmpop 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(int_cmpop_init,int_cmpop_expect), + .num_globals = num_globals(int_cmpop_init,int_cmpop_expect), .num_statements = num_statements (int_cmpop_4_statements), .statements = int_cmpop_4_statements, .init_globals = (pr_int_t *) int_cmpop_init, diff --git a/libs/gamecode/test/test-long.c b/libs/gamecode/test/test-long.c index fc1851151..36d62845e 100644 --- a/libs/gamecode/test/test-long.c +++ b/libs/gamecode/test/test-long.c @@ -194,7 +194,7 @@ test_t tests[] = { { .desc = "long binop 1", .extra_globals = 8 * 1, - .num_globals = 8*num_globals(long_binop_init,long_binop_expect), + .num_globals = num_globals(long_binop_init,long_binop_expect), .num_statements = num_statements (long_binop_1_statements), .statements = long_binop_1_statements, .init_globals = (pr_int_t *) long_binop_init, @@ -203,7 +203,7 @@ test_t tests[] = { { .desc = "long binop 2", .extra_globals = 8 * 1, - .num_globals = 8*num_globals(long_binop_init,long_binop_expect), + .num_globals = num_globals(long_binop_init,long_binop_expect), .num_statements = num_statements (long_binop_2_statements), .statements = long_binop_2_statements, .init_globals = (pr_int_t *) long_binop_init, @@ -212,7 +212,7 @@ test_t tests[] = { { .desc = "long binop 3a", .extra_globals = 8 * 1, - .num_globals = 8*num_globals(long_binop_init,long_binop_expect), + .num_globals = num_globals(long_binop_init,long_binop_expect), .num_statements = num_statements (long_binop_3a_statements), .statements = long_binop_3a_statements, .init_globals = (pr_int_t *) long_binop_init, @@ -221,7 +221,7 @@ test_t tests[] = { { .desc = "long binop 3b", .extra_globals = 8 * 1, - .num_globals = 8*num_globals(long_binop_init,long_binop_expect), + .num_globals = num_globals(long_binop_init,long_binop_expect), .num_statements = num_statements (long_binop_3b_statements), .statements = long_binop_3b_statements, .init_globals = (pr_int_t *) long_binop_init, @@ -230,7 +230,7 @@ test_t tests[] = { { .desc = "long binop 4", .extra_globals = 8 * 1, - .num_globals = 8*num_globals(long_binop_init,long_binop_expect), + .num_globals = num_globals(long_binop_init,long_binop_expect), .num_statements = num_statements (long_binop_4_statements), .statements = long_binop_4_statements, .init_globals = (pr_int_t *) long_binop_init, @@ -239,7 +239,7 @@ test_t tests[] = { { .desc = "long cmpop 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(long_cmpop_init,long_cmpop_expect), + .num_globals = num_globals(long_cmpop_init,long_cmpop_expect), .num_statements = num_statements (long_cmpop_1_statements), .statements = long_cmpop_1_statements, .init_globals = (pr_int_t *) long_cmpop_init, @@ -248,7 +248,7 @@ test_t tests[] = { { .desc = "long cmpop 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(long_cmpop_init,long_cmpop_expect), + .num_globals = num_globals(long_cmpop_init,long_cmpop_expect), .num_statements = num_statements (long_cmpop_2_statements), .statements = long_cmpop_2_statements, .init_globals = (pr_int_t *) long_cmpop_init, @@ -257,7 +257,7 @@ test_t tests[] = { { .desc = "long cmpop 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(long_cmpop_init,long_cmpop_expect), + .num_globals = num_globals(long_cmpop_init,long_cmpop_expect), .num_statements = num_statements (long_cmpop_3a_statements), .statements = long_cmpop_3a_statements, .init_globals = (pr_int_t *) long_cmpop_init, @@ -266,7 +266,7 @@ test_t tests[] = { { .desc = "long cmpop 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(long_cmpop_init,long_cmpop_expect), + .num_globals = num_globals(long_cmpop_init,long_cmpop_expect), .num_statements = num_statements (long_cmpop_3b_statements), .statements = long_cmpop_3b_statements, .init_globals = (pr_int_t *) long_cmpop_init, @@ -275,7 +275,7 @@ test_t tests[] = { { .desc = "long cmpop 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(long_cmpop_init,long_cmpop_expect), + .num_globals = num_globals(long_cmpop_init,long_cmpop_expect), .num_statements = num_statements (long_cmpop_4_statements), .statements = long_cmpop_4_statements, .init_globals = (pr_int_t *) long_cmpop_init, diff --git a/libs/gamecode/test/test-unsigned.c b/libs/gamecode/test/test-unsigned.c index 298ed5c26..de9fd3bfa 100644 --- a/libs/gamecode/test/test-unsigned.c +++ b/libs/gamecode/test/test-unsigned.c @@ -304,7 +304,7 @@ static pr_ulvec4_t ulong_shiftop_expect[] = { { UINT64_C(0x456789abcdef0000), UINT64_C(0xdef0123456780000), UINT64_C(0x0000030000000200), UINT64_C(0x5554aaab5554aaaa) },//shl a { UINT64_C(0xef00000000000000), UINT64_C(0x5678000000000000), - UINT64_C(0x0020000000000000), UINT64_C(0x8000000000000000) },//shl b + UINT64_C(0x0080000000000000), UINT64_C(0x8000000000000000) },//shl b { UINT64_C(0x000123456789abcd), UINT64_C(0x00009abcdef01234), UINT64_C(0x0040000000c00000), UINT64_C(0x55552aaad5552aaa) },//shr a { UINT64_C(0x0000000000000123), UINT64_C(0x0000000000009abc), @@ -390,7 +390,7 @@ test_t tests[] = { { .desc = "uint cmpop 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_cmpop_init,uint_cmpop_expect), + .num_globals = num_globals(uint_cmpop_init,uint_cmpop_expect), .num_statements = num_statements (uint_cmpop_1_statements), .statements = uint_cmpop_1_statements, .init_globals = (pr_int_t *) uint_cmpop_init, @@ -399,7 +399,7 @@ test_t tests[] = { { .desc = "uint cmpop 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_cmpop_init,uint_cmpop_expect), + .num_globals = num_globals(uint_cmpop_init,uint_cmpop_expect), .num_statements = num_statements (uint_cmpop_2_statements), .statements = uint_cmpop_2_statements, .init_globals = (pr_int_t *) uint_cmpop_init, @@ -408,7 +408,7 @@ test_t tests[] = { { .desc = "uint cmpop 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_cmpop_init,uint_cmpop_expect), + .num_globals = num_globals(uint_cmpop_init,uint_cmpop_expect), .num_statements = num_statements (uint_cmpop_3a_statements), .statements = uint_cmpop_3a_statements, .init_globals = (pr_int_t *) uint_cmpop_init, @@ -417,7 +417,7 @@ test_t tests[] = { { .desc = "uint cmpop 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_cmpop_init,uint_cmpop_expect), + .num_globals = num_globals(uint_cmpop_init,uint_cmpop_expect), .num_statements = num_statements (uint_cmpop_3b_statements), .statements = uint_cmpop_3b_statements, .init_globals = (pr_int_t *) uint_cmpop_init, @@ -426,7 +426,7 @@ test_t tests[] = { { .desc = "uint cmpop 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_cmpop_init,uint_cmpop_expect), + .num_globals = num_globals(uint_cmpop_init,uint_cmpop_expect), .num_statements = num_statements (uint_cmpop_4_statements), .statements = uint_cmpop_4_statements, .init_globals = (pr_int_t *) uint_cmpop_init, @@ -435,7 +435,7 @@ test_t tests[] = { { .desc = "ulong cmpop 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_cmpop_init,ulong_cmpop_expect), + .num_globals = num_globals(ulong_cmpop_init,ulong_cmpop_expect), .num_statements = num_statements (ulong_cmpop_1_statements), .statements = ulong_cmpop_1_statements, .init_globals = (pr_int_t *) ulong_cmpop_init, @@ -444,7 +444,7 @@ test_t tests[] = { { .desc = "ulong cmpop 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_cmpop_init,ulong_cmpop_expect), + .num_globals = num_globals(ulong_cmpop_init,ulong_cmpop_expect), .num_statements = num_statements (ulong_cmpop_2_statements), .statements = ulong_cmpop_2_statements, .init_globals = (pr_int_t *) ulong_cmpop_init, @@ -453,7 +453,7 @@ test_t tests[] = { { .desc = "ulong cmpop 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_cmpop_init,ulong_cmpop_expect), + .num_globals = num_globals(ulong_cmpop_init,ulong_cmpop_expect), .num_statements = num_statements (ulong_cmpop_3a_statements), .statements = ulong_cmpop_3a_statements, .init_globals = (pr_int_t *) ulong_cmpop_init, @@ -462,7 +462,7 @@ test_t tests[] = { { .desc = "ulong cmpop 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_cmpop_init,ulong_cmpop_expect), + .num_globals = num_globals(ulong_cmpop_init,ulong_cmpop_expect), .num_statements = num_statements (ulong_cmpop_3b_statements), .statements = ulong_cmpop_3b_statements, .init_globals = (pr_int_t *) ulong_cmpop_init, @@ -471,7 +471,7 @@ test_t tests[] = { { .desc = "ulong cmpop 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_cmpop_init,ulong_cmpop_expect), + .num_globals = num_globals(ulong_cmpop_init,ulong_cmpop_expect), .num_statements = num_statements (ulong_cmpop_4_statements), .statements = ulong_cmpop_4_statements, .init_globals = (pr_int_t *) ulong_cmpop_init, @@ -480,7 +480,7 @@ test_t tests[] = { { .desc = "uint shiftop 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_shiftop_init,uint_shiftop_expect), + .num_globals = num_globals(uint_shiftop_init,uint_shiftop_expect), .num_statements = num_statements (uint_shiftop_1_statements), .statements = uint_shiftop_1_statements, .init_globals = (pr_int_t *) uint_shiftop_init, @@ -489,7 +489,7 @@ test_t tests[] = { { .desc = "uint shiftop 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_shiftop_init,uint_shiftop_expect), + .num_globals = num_globals(uint_shiftop_init,uint_shiftop_expect), .num_statements = num_statements (uint_shiftop_2_statements), .statements = uint_shiftop_2_statements, .init_globals = (pr_int_t *) uint_shiftop_init, @@ -498,7 +498,7 @@ test_t tests[] = { { .desc = "uint shiftop 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_shiftop_init,uint_shiftop_expect), + .num_globals = num_globals(uint_shiftop_init,uint_shiftop_expect), .num_statements = num_statements (uint_shiftop_3a_statements), .statements = uint_shiftop_3a_statements, .init_globals = (pr_int_t *) uint_shiftop_init, @@ -507,7 +507,7 @@ test_t tests[] = { { .desc = "uint shiftop 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_shiftop_init,uint_shiftop_expect), + .num_globals = num_globals(uint_shiftop_init,uint_shiftop_expect), .num_statements = num_statements (uint_shiftop_3b_statements), .statements = uint_shiftop_3b_statements, .init_globals = (pr_int_t *) uint_shiftop_init, @@ -516,7 +516,7 @@ test_t tests[] = { { .desc = "uint shiftop 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(uint_shiftop_init,uint_shiftop_expect), + .num_globals = num_globals(uint_shiftop_init,uint_shiftop_expect), .num_statements = num_statements (uint_shiftop_4_statements), .statements = uint_shiftop_4_statements, .init_globals = (pr_int_t *) uint_shiftop_init, @@ -525,7 +525,7 @@ test_t tests[] = { { .desc = "ulong shiftop 1", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_shiftop_init,ulong_shiftop_expect), + .num_globals = num_globals(ulong_shiftop_init,ulong_shiftop_expect), .num_statements = num_statements (ulong_shiftop_1_statements), .statements = ulong_shiftop_1_statements, .init_globals = (pr_int_t *) ulong_shiftop_init, @@ -534,7 +534,7 @@ test_t tests[] = { { .desc = "ulong shiftop 2", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_shiftop_init,ulong_shiftop_expect), + .num_globals = num_globals(ulong_shiftop_init,ulong_shiftop_expect), .num_statements = num_statements (ulong_shiftop_2_statements), .statements = ulong_shiftop_2_statements, .init_globals = (pr_int_t *) ulong_shiftop_init, @@ -543,7 +543,7 @@ test_t tests[] = { { .desc = "ulong shiftop 3a", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_shiftop_init,ulong_shiftop_expect), + .num_globals = num_globals(ulong_shiftop_init,ulong_shiftop_expect), .num_statements = num_statements (ulong_shiftop_3a_statements), .statements = ulong_shiftop_3a_statements, .init_globals = (pr_int_t *) ulong_shiftop_init, @@ -552,7 +552,7 @@ test_t tests[] = { { .desc = "ulong shiftop 3b", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_shiftop_init,ulong_shiftop_expect), + .num_globals = num_globals(ulong_shiftop_init,ulong_shiftop_expect), .num_statements = num_statements (ulong_shiftop_3b_statements), .statements = ulong_shiftop_3b_statements, .init_globals = (pr_int_t *) ulong_shiftop_init, @@ -561,7 +561,7 @@ test_t tests[] = { { .desc = "ulong shiftop 4", .extra_globals = 4 * 1, - .num_globals = 4*num_globals(ulong_shiftop_init,ulong_shiftop_expect), + .num_globals = num_globals(ulong_shiftop_init,ulong_shiftop_expect), .num_statements = num_statements (ulong_shiftop_4_statements), .statements = ulong_shiftop_4_statements, .init_globals = (pr_int_t *) ulong_shiftop_init, diff --git a/libs/gamecode/test/test-vector.c b/libs/gamecode/test/test-vector.c index 814893f86..f80253886 100644 --- a/libs/gamecode/test/test-vector.c +++ b/libs/gamecode/test/test-vector.c @@ -151,7 +151,7 @@ static dstatement_t double_vector_statements[] = { test_t tests[] = { { .desc = "float vector", - .num_globals = 4*num_globals(float_globals_init, float_globals_expect), + .num_globals = num_globals(float_globals_init, float_globals_expect), .num_statements = num_statements (float_vector_statements), .statements = float_vector_statements, .init_globals = (pr_int_t *) float_globals_init, @@ -159,7 +159,7 @@ test_t tests[] = { }, { .desc = "double vector", - .num_globals = 8*num_globals(double_globals_init,double_globals_expect), + .num_globals = num_globals(double_globals_init,double_globals_expect), .num_statements = num_statements (double_vector_statements), .statements = double_vector_statements, .init_globals = (pr_int_t *) double_globals_init, From f4eeed36b7331aa61c54337f8c006e97d04cdf96 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 14 Jan 2022 19:46:35 +0900 Subject: [PATCH 101/360] [gamecode] Add tests for the scale instructions --- libs/gamecode/test/Makemodule.am | 6 +++ libs/gamecode/test/test-scale.c | 68 ++++++++++++++++++++++++++++++++ 2 files changed, 74 insertions(+) create mode 100644 libs/gamecode/test/test-scale.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index a878155d1..8bb1e3772 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -12,6 +12,7 @@ libs_gamecode_tests = \ libs/gamecode/test/test-int \ libs/gamecode/test/test-load \ libs/gamecode/test/test-long \ + libs/gamecode/test/test-scale \ libs/gamecode/test/test-stack \ libs/gamecode/test/test-store \ libs/gamecode/test/test-unsigned \ @@ -92,6 +93,11 @@ libs_gamecode_test_test_long_SOURCES= \ libs_gamecode_test_test_long_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_long_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_scale_SOURCES= \ + libs/gamecode/test/test-scale.c +libs_gamecode_test_test_scale_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_scale_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_stack_SOURCES= \ libs/gamecode/test/test-stack.c libs_gamecode_test_test_stack_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-scale.c b/libs/gamecode/test/test-scale.c new file mode 100644 index 000000000..4117fd718 --- /dev/null +++ b/libs/gamecode/test/test-scale.c @@ -0,0 +1,68 @@ +#include "head.c" + +#include "QF/mathlib.h" + +static pr_vec4_t float_scale_init[] = { + { 5, 0, 0, 0}, + { 3, 4, 13, 85}, + { 0, 0, -1, -2}, + { 0, 0, 0, -3}, + { 0, 0, 0, 0}, +}; + +static pr_vec4_t float_scale_expect[] = { + { 5, 0, 0, 0}, + { 3, 4, 13, 85}, + { 15, 20, -1, -2}, + { 15, 20, 65, -3}, + { 15, 20, 65, 425}, +}; + +static dstatement_t float_scale_statements[] = { + { OP(1, 1, 1, OP_SCALE_F_2), 4, 0, 8 }, + { OP(1, 1, 1, OP_SCALE_F_3), 4, 0, 12 }, + { OP(1, 1, 1, OP_SCALE_F_4), 4, 0, 16 }, +}; + +static pr_dvec4_t double_scale_init[] = { + { 5, 0, 0, 0}, + { 3, 4, 13, 85}, + { 0, 0, -1, -2}, + { 0, 0, 0, -3}, + { 0, 0, 0, 0}, +}; + +static pr_dvec4_t double_scale_expect[] = { + { 5, 0, 0, 0}, + { 3, 4, 13, 85}, + { 15, 20, -1, -2}, + { 15, 20, 65, -3}, + { 15, 20, 65, 425}, +}; + +static dstatement_t double_scale_statements[] = { + { OP(1, 1, 1, OP_SCALE_D_2), 8, 0, 16 }, + { OP(1, 1, 1, OP_SCALE_D_3), 8, 0, 24 }, + { OP(1, 1, 1, OP_SCALE_D_4), 8, 0, 32 }, +}; + +test_t tests[] = { + { + .desc = "float scale", + .num_globals = num_globals(float_scale_init,float_scale_expect), + .num_statements = num_statements (float_scale_statements), + .statements = float_scale_statements, + .init_globals = (pr_int_t *) float_scale_init, + .expect_globals = (pr_int_t *) float_scale_expect, + }, + { + .desc = "double scale", + .num_globals = num_globals(double_scale_init,double_scale_expect), + .num_statements = num_statements (double_scale_statements), + .statements = double_scale_statements, + .init_globals = (pr_int_t *) double_scale_init, + .expect_globals = (pr_int_t *) double_scale_expect, + }, +}; + +#include "main.c" From c8362c28fec60038246b1be24d19c65732695779 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 14 Jan 2022 22:42:56 +0900 Subject: [PATCH 102/360] [gamecode] Add tests for string ops Does not include string concatenation because I don't feel like messing with zone init, but all the other operators are tested (currently failing due to bool convention) --- libs/gamecode/test/Makemodule.am | 6 +++ libs/gamecode/test/head.c | 2 + libs/gamecode/test/main.c | 8 ++++ libs/gamecode/test/test-string.c | 82 ++++++++++++++++++++++++++++++++ 4 files changed, 98 insertions(+) create mode 100644 libs/gamecode/test/test-string.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index 8bb1e3772..ba3bc174a 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -15,6 +15,7 @@ libs_gamecode_tests = \ libs/gamecode/test/test-scale \ libs/gamecode/test/test-stack \ libs/gamecode/test/test-store \ + libs/gamecode/test/test-string \ libs/gamecode/test/test-unsigned \ libs/gamecode/test/test-vector @@ -108,6 +109,11 @@ libs_gamecode_test_test_store_SOURCES= \ libs_gamecode_test_test_store_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_store_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_string_SOURCES= \ + libs/gamecode/test/test-string.c +libs_gamecode_test_test_string_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_string_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_vector_SOURCES= \ libs/gamecode/test/test-vector.c libs_gamecode_test_test_vector_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/head.c b/libs/gamecode/test/head.c index 36985c821..478a74f09 100644 --- a/libs/gamecode/test/head.c +++ b/libs/gamecode/test/head.c @@ -34,4 +34,6 @@ typedef struct { dstatement_t *statements; pr_int_t *init_globals; pr_int_t *expect_globals; + const char *strings; + pr_uint_t string_size; } test_t; diff --git a/libs/gamecode/test/main.c b/libs/gamecode/test/main.c index 0579463b2..8f433225c 100644 --- a/libs/gamecode/test/main.c +++ b/libs/gamecode/test/main.c @@ -44,10 +44,15 @@ test_debug_handler (prdebug_t event, void *param, void *data) case prd_trace: dstatement_t *st = test_pr.pr_statements + test_pr.pr_xstatement; if (verbose > 1) { + printf ("---\n"); printf ("debug: trace %05x %04x %04x %04x %04x%s\n", test_pr.pr_xstatement, st->op, st->a, st->b, st->c, pr->globals.stack ? va (0, " %05x", *pr->globals.stack) : ""); + printf (" %04x %04x %04x\n", + st->a + PR_BASE (pr, st, A), + st->b + PR_BASE (pr, st, B), + st->c + PR_BASE (pr, st, C)); } if (verbose > 0) { PR_PrintStatement (&test_pr, st, 0); @@ -111,6 +116,9 @@ setup_test (test_t *test) (test->num_statements + 1) * sizeof (dstatement_t)); test_pr.pr_statements[test->num_statements] = (dstatement_t) { OP_BREAK, 0, 0, 0 }; + + test_pr.pr_strings = (char *) test->strings; + test_pr.pr_stringsize = test->string_size; } static int diff --git a/libs/gamecode/test/test-string.c b/libs/gamecode/test/test-string.c new file mode 100644 index 000000000..4e2e7faad --- /dev/null +++ b/libs/gamecode/test/test-string.c @@ -0,0 +1,82 @@ +#include "head.c" + +const char test_strings[] = + "\0" + "abc\0" + "def\0" + "abc\0"; + +static pr_int_t string_globals_init[] = { + 0, 1, 5, 9, // string pointers + 0, 0, 0, 0, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, +}; + +static pr_int_t string_globals_expect[] = { + 0, 1, 5, 9, // string pointers + 0, 0, 8, 0, + +// "\0" "abc" "def" "abc" + -1, 0, 0, 0, 0, -1, 0, -1, 0, 0, -1, 0, 0, -1, 0, -1, // eq + 0, -1, -1, -1, 0, 0, -1, 0, 0, 0, 0, 0, 0, 0, -1, 0, // lt + 0, 0, 0, 0, -1, 0, 0, 0, -1, -1, 0, -1, -1, 0, 0, 0, // gt + 0,-97,-100,-97, 97, 0, -3, 0, 100, 3, 0, 3, 97, 0, -3, 0, // cmp + -1, 0, 0, 0, -1, -1, 0, -1, -1, -1, -1, -1, -1, -1, 0, -1, // ge + -1, -1, -1, -1, 0, -1, -1, -1, 0, 0, -1, 0, 0, -1, -1, -1, // le + -1, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // not +}; + +static dstatement_t string_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 24, 0, 6 }, // init k +// for (i = 4; i-- > 0; ) { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 4 }, + { OP(0, 0, 0, OP_IFA_A), 2, 0, 4 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_LEA_C), 4, -1, 4 }, // dec i + + { OP(0, 0, 0, OP_WITH), 4, 4, 1 }, // load i + +// for (j = 4; j-- > 0; ) { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 5 }, // init j + + { OP(0, 0, 0, OP_IFA_A), 2, 0, 5 }, + { OP(0, 0, 0, OP_JUMP_A), -6, 0, 0 }, + { OP(0, 0, 0, OP_LEA_C), 5, -1, 5 }, // dec j + + { OP(0, 0, 0, OP_WITH), 4, 5, 2 }, // load j + + { OP(0, 0, 0, OP_LEA_C), 6, -1, 6 }, // dec k + { OP(0, 0, 0, OP_WITH), 4, 6, 3 }, // load k + + // i j k + { OP(1, 2, 3, OP_EQ_S), 0, 0, 0 }, + { OP(1, 2, 3, OP_LT_S), 0, 0, 16 }, + { OP(1, 2, 3, OP_GT_S), 0, 0, 32 }, + { OP(1, 2, 3, OP_CMP_S), 0, 0, 48 }, + { OP(1, 2, 3, OP_GE_S), 0, 0, 64 }, + { OP(1, 2, 3, OP_LE_S), 0, 0, 80 }, + { OP(1, 2, 3, OP_NOT_S), 0, 0, 96 }, + + { OP(0, 0, 0, OP_JUMP_A), -13, 0, 0 }, +}; + +test_t tests[] = { + { + .desc = "string", + .num_globals = num_globals (string_globals_init, string_globals_expect), + .num_statements = num_statements (string_statements), + .statements = string_statements, + .init_globals = string_globals_init, + .expect_globals = string_globals_expect, + .strings = test_strings, + .string_size = sizeof (test_strings), + }, +}; + +#include "main.c" From 1aa4844bf63147010345d75169e5de93d97da6f3 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 14 Jan 2022 22:44:08 +0900 Subject: [PATCH 103/360] [gamecode] Make string ops mostly conform with bools The compare/ne operator returns "random" -ve, 0, +ve values (really, just the numerical difference between the chars of the strings), but all the rest return -1 for true and 0 for false, as with the rest of the comparison operators. --- libs/gamecode/pr_exec.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 86903f7eb..abe934815 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -3280,12 +3280,12 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) int cmp = strcmp (PR_GetString (pr, OPA(string)), PR_GetString (pr, OPB(string))); switch (st_op) { - case OP_EQ_S: cmp = (cmp == 0); break; - case OP_LT_S: cmp = (cmp < 0); break; - case OP_GT_S: cmp = (cmp > 0); break; - case OP_GE_S: cmp = (cmp >= 0); break; - case OP_LE_S: cmp = (cmp <= 0); break; - case OP_NOT_S: break; + case OP_EQ_S: cmp = -(cmp == 0); break; + case OP_LT_S: cmp = -(cmp < 0); break; + case OP_GT_S: cmp = -(cmp > 0); break; + case OP_GE_S: cmp = -(cmp >= 0); break; + case OP_LE_S: cmp = -(cmp <= 0); break; + case OP_CMP_S: break; default: break; } OPC(int) = cmp; @@ -3296,7 +3296,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) PR_GetString (pr, OPB(string))); break; case OP_NOT_S: - OPC(int) = !OPA(string) || !*PR_GetString (pr, OPA(string)); + OPC(int) = -(!OPA(string) || !*PR_GetString (pr, OPA(string))); break; // 1 0111 OP_op_T (ASR, I, int, ivec2, ivec4, >>); From 6f1f56aea75ba9158f5c4b0cfe5e0ff1af2875e2 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 14 Jan 2022 22:51:18 +0900 Subject: [PATCH 104/360] [gamecode] Make commented braces match They annoyed me --- libs/gamecode/test/test-string.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libs/gamecode/test/test-string.c b/libs/gamecode/test/test-string.c index 4e2e7faad..a723eebb7 100644 --- a/libs/gamecode/test/test-string.c +++ b/libs/gamecode/test/test-string.c @@ -63,7 +63,9 @@ static dstatement_t string_statements[] = { { OP(1, 2, 3, OP_LE_S), 0, 0, 80 }, { OP(1, 2, 3, OP_NOT_S), 0, 0, 96 }, +// } { OP(0, 0, 0, OP_JUMP_A), -13, 0, 0 }, +// } }; test_t tests[] = { From 7cd398d4a752ee953aee56318cfd9a11522db88d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 15 Jan 2022 13:20:33 +0900 Subject: [PATCH 105/360] [gamecodee] Add tests for move and memset --- libs/gamecode/test/Makemodule.am | 6 ++++ libs/gamecode/test/test-mem.c | 51 ++++++++++++++++++++++++++++++++ 2 files changed, 57 insertions(+) create mode 100644 libs/gamecode/test/test-mem.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index ba3bc174a..58552d1b9 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -12,6 +12,7 @@ libs_gamecode_tests = \ libs/gamecode/test/test-int \ libs/gamecode/test/test-load \ libs/gamecode/test/test-long \ + libs/gamecode/test/test-mem \ libs/gamecode/test/test-scale \ libs/gamecode/test/test-stack \ libs/gamecode/test/test-store \ @@ -94,6 +95,11 @@ libs_gamecode_test_test_long_SOURCES= \ libs_gamecode_test_test_long_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_long_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_mem_SOURCES= \ + libs/gamecode/test/test-mem.c +libs_gamecode_test_test_mem_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_mem_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_scale_SOURCES= \ libs/gamecode/test/test-scale.c libs_gamecode_test_test_scale_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-mem.c b/libs/gamecode/test/test-mem.c new file mode 100644 index 000000000..1bba532e8 --- /dev/null +++ b/libs/gamecode/test/test-mem.c @@ -0,0 +1,51 @@ +#include "head.c" + +#define DB 0xdeadbeef + +static pr_int_t mem_globals_init[] = { + 0, 8, 68, 9, 80, 112, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, + 0, 0, 68, 6, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 + + DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, + DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, + DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, + DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, + DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, + DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, +}; + +static pr_int_t mem_globals_expect[] = { + 0, 8, 68, 9, 80, 112, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, // 0 + 0, 0, 68, 6, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 + + DB, 0, 0, 0, 0, 0, DB, DB, 9, 9, DB, DB, DB, DB, DB, DB, // 32 + 1, 2, 3, 4, 5, 6, 7, 8, DB, DB, DB, DB, 5, 6, 7, 8, // 48 + DB, DB, DB, DB, 1, 2, 1, 2, 3, 4, 5, 6, DB, DB, DB, DB, // 64 + 68, 68, 68, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, // 80 + DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, DB, // 96 + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, DB, // 112 +}; + +static dstatement_t mem_statements[] = { + {OP(0, 0, 0, OP_MEMSET_I), 0, 5, 33}, + {OP(0, 0, 0, OP_MEMSET_I), 3, 2, 40}, + {OP(0, 0, 0, OP_MOVE_I), 8, 8, 48}, + {OP(0, 0, 0, OP_MOVE_I), 12, 4, 60}, + {OP(0, 0, 0, OP_MOVE_PI), 1, 8, 2}, + {OP(0, 0, 0, OP_MEMSET_P), 2, 10, 4}, + {OP(0, 0, 0, OP_MEMSET_PI), 1, 15, 5}, + {OP(0, 0, 0, OP_MOVE_P), 18, 19, 20}, +}; + +test_t tests[] = { + { + .desc = "mem", + .num_globals = num_globals (mem_globals_init, mem_globals_expect), + .num_statements = num_statements (mem_statements), + .statements = mem_statements, + .init_globals = mem_globals_init, + .expect_globals = mem_globals_expect, + }, +}; + +#include "main.c" From bffcbfc9fcd4829d40910c0a8efff2e2ee587580 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 15 Jan 2022 13:59:03 +0900 Subject: [PATCH 106/360] [gamecode] Add tests for bitops --- libs/gamecode/test/Makemodule.am | 6 + libs/gamecode/test/test-bitops.c | 260 +++++++++++++++++++++++++++++++ 2 files changed, 266 insertions(+) create mode 100644 libs/gamecode/test/test-bitops.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index 58552d1b9..cdc0824a6 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -1,4 +1,5 @@ libs_gamecode_tests = \ + libs/gamecode/test/test-bitops \ libs/gamecode/test/test-conv0 \ libs/gamecode/test/test-conv1 \ libs/gamecode/test/test-conv2 \ @@ -30,6 +31,11 @@ test_gamecode_libs= \ libs/gamecode/libQFgamecode.la \ libs/util/libQFutil.la +libs_gamecode_test_test_bitops_SOURCES= \ + libs/gamecode/test/test-bitops.c +libs_gamecode_test_test_bitops_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_bitops_DEPENDENCIES=$(test_gamecode_libs) + libs_gamecode_test_test_conv0_SOURCES= \ libs/gamecode/test/test-conv0.c libs_gamecode_test_test_conv0_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-bitops.c b/libs/gamecode/test/test-bitops.c new file mode 100644 index 000000000..a3121eb46 --- /dev/null +++ b/libs/gamecode/test/test-bitops.c @@ -0,0 +1,260 @@ +#include "head.c" + +#include "QF/mathlib.h" + +static pr_ivec4_t int_bitop_init[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_ivec4_t int_bitop_expect[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + + { 5, 1, 1, -5}, + { 5, -1, -1, -5}, + { 0, -2, -2, 0}, + { -6, 4, -6, 4}, +}; + +static dstatement_t int_bitop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 24 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 24, -1, 24 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 24 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 24, 1 }, + + { OP(1, 1, 1, OP_BITAND_I_1), 0, 4, 8}, + { OP(1, 1, 1, OP_BITOR_I_1), 0, 4, 12}, + { OP(1, 1, 1, OP_BITXOR_I_1), 0, 4, 16}, + { OP(1, 1, 1, OP_BITNOT_I_1), 0, 4, 20}, + + { OP(0, 0, 0, OP_JUMP_A), -8, 0, 0 }, +}; + +static dstatement_t int_bitop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 24 }, // index +//loop: + { OP(0, 0, 0, OP_LEA_C), 24, -2, 24 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 24 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 24, 1 }, + + { OP(1, 1, 1, OP_BITAND_I_2), 0, 4, 8}, + { OP(1, 1, 1, OP_BITOR_I_2), 0, 4, 12}, + { OP(1, 1, 1, OP_BITXOR_I_2), 0, 4, 16}, + { OP(1, 1, 1, OP_BITNOT_I_2), 0, 4, 20}, + + { OP(0, 0, 0, OP_JUMP_A), -8, 0, 0 }, +}; + +static dstatement_t int_bitop_3a_statements[] = { + { OP(1, 1, 1, OP_BITAND_I_3), 0, 4, 8}, + { OP(1, 1, 1, OP_BITAND_I_1), 3, 7, 11}, + { OP(1, 1, 1, OP_BITOR_I_3), 0, 4, 12}, + { OP(1, 1, 1, OP_BITOR_I_1), 3, 7, 15}, + { OP(1, 1, 1, OP_BITXOR_I_3), 0, 4, 16}, + { OP(1, 1, 1, OP_BITXOR_I_1), 3, 7, 19}, + { OP(1, 1, 1, OP_BITNOT_I_3), 0, 4, 20}, + { OP(1, 1, 1, OP_BITNOT_I_1), 3, 7, 23}, +}; + +static dstatement_t int_bitop_3b_statements[] = { + { OP(1, 1, 1, OP_BITAND_I_1), 0, 4, 8}, + { OP(1, 1, 1, OP_BITAND_I_3), 1, 5, 9}, + { OP(1, 1, 1, OP_BITOR_I_1), 0, 4, 12}, + { OP(1, 1, 1, OP_BITOR_I_3), 1, 5, 13}, + { OP(1, 1, 1, OP_BITXOR_I_1), 0, 4, 16}, + { OP(1, 1, 1, OP_BITXOR_I_3), 1, 5, 17}, + { OP(1, 1, 1, OP_BITNOT_I_1), 0, 4, 20}, + { OP(1, 1, 1, OP_BITNOT_I_3), 1, 5, 21}, +}; + +static dstatement_t int_bitop_4_statements[] = { + { OP(1, 1, 1, OP_BITAND_I_4), 0, 4, 8}, + { OP(1, 1, 1, OP_BITOR_I_4), 0, 4, 12}, + { OP(1, 1, 1, OP_BITXOR_I_4), 0, 4, 16}, + { OP(1, 1, 1, OP_BITNOT_I_4), 0, 4, 20}, +}; + +static pr_lvec4_t long_bitop_init[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_lvec4_t long_bitop_expect[] = { + { 5, -5, 5, -5}, + { 5, 5, -5, -5}, + + { 5, 1, 1, -5}, + { 5, -1, -1, -5}, + { 0, -2, -2, 0}, + { -6, 4, -6, 4}, +}; + +static dstatement_t long_bitop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 48 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 48, -2, 48 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 48 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 48, 1 }, + + { OP(1, 1, 1, OP_BITAND_L_1), 0, 8, 16}, + { OP(1, 1, 1, OP_BITOR_L_1), 0, 8, 24}, + { OP(1, 1, 1, OP_BITXOR_L_1), 0, 8, 32}, + { OP(1, 1, 1, OP_BITNOT_L_1), 0, 8, 40}, + + { OP(0, 0, 0, OP_JUMP_A), -8, 0, 0 }, +}; + +static dstatement_t long_bitop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 48 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 48, -4, 48 }, // dec index + { OP(0, 0, 0, OP_IFAE_A), 2, 0, 48 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 48, 1 }, + + { OP(1, 1, 1, OP_BITAND_L_2), 0, 8, 16}, + { OP(1, 1, 1, OP_BITOR_L_2), 0, 8, 24}, + { OP(1, 1, 1, OP_BITXOR_L_2), 0, 8, 32}, + { OP(1, 1, 1, OP_BITNOT_L_2), 0, 8, 40}, + + { OP(0, 0, 0, OP_JUMP_A), -8, 0, 0 }, +}; + +static dstatement_t long_bitop_3a_statements[] = { + { OP(1, 1, 1, OP_BITAND_L_3), 0, 8, 16}, + { OP(1, 1, 1, OP_BITAND_L_1), 6, 14, 22}, + { OP(1, 1, 1, OP_BITOR_L_3), 0, 8, 24}, + { OP(1, 1, 1, OP_BITOR_L_1), 6, 14, 30}, + { OP(1, 1, 1, OP_BITXOR_L_3), 0, 8, 32}, + { OP(1, 1, 1, OP_BITXOR_L_1), 6, 14, 38}, + { OP(1, 1, 1, OP_BITNOT_L_3), 0, 8, 40}, + { OP(1, 1, 1, OP_BITNOT_L_1), 6, 14, 46}, +}; + +static dstatement_t long_bitop_3b_statements[] = { + { OP(1, 1, 1, OP_BITAND_L_1), 0, 8, 16}, + { OP(1, 1, 1, OP_BITAND_L_3), 2, 10, 18}, + { OP(1, 1, 1, OP_BITOR_L_1), 0, 8, 24}, + { OP(1, 1, 1, OP_BITOR_L_3), 2, 10, 26}, + { OP(1, 1, 1, OP_BITXOR_L_1), 0, 8, 32}, + { OP(1, 1, 1, OP_BITXOR_L_3), 2, 10, 34}, + { OP(1, 1, 1, OP_BITNOT_L_1), 0, 8, 40}, + { OP(1, 1, 1, OP_BITNOT_L_3), 2, 10, 42}, +}; + +static dstatement_t long_bitop_4_statements[] = { + { OP(1, 1, 1, OP_BITAND_L_4), 0, 8, 16}, + { OP(1, 1, 1, OP_BITOR_L_4), 0, 8, 24}, + { OP(1, 1, 1, OP_BITXOR_L_4), 0, 8, 32}, + { OP(1, 1, 1, OP_BITNOT_L_4), 0, 8, 40}, +}; + +test_t tests[] = { + { + .desc = "int bitop 1", + .extra_globals = 4 * 1, + .num_globals = num_globals(int_bitop_init,int_bitop_expect), + .num_statements = num_statements (int_bitop_1_statements), + .statements = int_bitop_1_statements, + .init_globals = (pr_int_t *) int_bitop_init, + .expect_globals = (pr_int_t *) int_bitop_expect, + }, + { + .desc = "int bitop 2", + .extra_globals = 4 * 1, + .num_globals = num_globals(int_bitop_init,int_bitop_expect), + .num_statements = num_statements (int_bitop_2_statements), + .statements = int_bitop_2_statements, + .init_globals = (pr_int_t *) int_bitop_init, + .expect_globals = (pr_int_t *) int_bitop_expect, + }, + { + .desc = "int bitop 3a", + .extra_globals = 4 * 1, + .num_globals = num_globals(int_bitop_init,int_bitop_expect), + .num_statements = num_statements (int_bitop_3a_statements), + .statements = int_bitop_3a_statements, + .init_globals = (pr_int_t *) int_bitop_init, + .expect_globals = (pr_int_t *) int_bitop_expect, + }, + { + .desc = "int bitop 3b", + .extra_globals = 4 * 1, + .num_globals = num_globals(int_bitop_init,int_bitop_expect), + .num_statements = num_statements (int_bitop_3b_statements), + .statements = int_bitop_3b_statements, + .init_globals = (pr_int_t *) int_bitop_init, + .expect_globals = (pr_int_t *) int_bitop_expect, + }, + { + .desc = "int bitop 4", + .extra_globals = 4 * 1, + .num_globals = num_globals(int_bitop_init,int_bitop_expect), + .num_statements = num_statements (int_bitop_4_statements), + .statements = int_bitop_4_statements, + .init_globals = (pr_int_t *) int_bitop_init, + .expect_globals = (pr_int_t *) int_bitop_expect, + }, + { + .desc = "long bitop 1", + .extra_globals = 4 * 1, + .num_globals = num_globals(long_bitop_init,long_bitop_expect), + .num_statements = num_statements (long_bitop_1_statements), + .statements = long_bitop_1_statements, + .init_globals = (pr_int_t *) long_bitop_init, + .expect_globals = (pr_int_t *) long_bitop_expect, + }, + { + .desc = "long bitop 2", + .extra_globals = 4 * 1, + .num_globals = num_globals(long_bitop_init,long_bitop_expect), + .num_statements = num_statements (long_bitop_2_statements), + .statements = long_bitop_2_statements, + .init_globals = (pr_int_t *) long_bitop_init, + .expect_globals = (pr_int_t *) long_bitop_expect, + }, + { + .desc = "long bitop 3a", + .extra_globals = 4 * 1, + .num_globals = num_globals(long_bitop_init,long_bitop_expect), + .num_statements = num_statements (long_bitop_3a_statements), + .statements = long_bitop_3a_statements, + .init_globals = (pr_int_t *) long_bitop_init, + .expect_globals = (pr_int_t *) long_bitop_expect, + }, + { + .desc = "long bitop 3b", + .extra_globals = 4 * 1, + .num_globals = num_globals(long_bitop_init,long_bitop_expect), + .num_statements = num_statements (long_bitop_3b_statements), + .statements = long_bitop_3b_statements, + .init_globals = (pr_int_t *) long_bitop_init, + .expect_globals = (pr_int_t *) long_bitop_expect, + }, + { + .desc = "long bitop 4", + .extra_globals = 4 * 1, + .num_globals = num_globals(long_bitop_init,long_bitop_expect), + .num_statements = num_statements (long_bitop_4_statements), + .statements = long_bitop_4_statements, + .init_globals = (pr_int_t *) long_bitop_init, + .expect_globals = (pr_int_t *) long_bitop_expect, + }, +}; + +#include "main.c" From fae432f46e23de7b123c38c9aed9285ca874f3cf Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 15 Jan 2022 15:44:53 +0900 Subject: [PATCH 107/360] [gamecode] Make no-op conversions simple copies Most useful for 64-bit values as only one instruction is needed to move the data around rather than two, but could be slightly faster for 32-bit as the addressing is simpler (needs profiling). --- libs/gamecode/convert.py | 19 +++++++++++++++---- libs/gamecode/test/test-conv0.c | 22 ++++++++++++++++++---- libs/gamecode/test/test-conv1.c | 13 ++++++++++--- libs/gamecode/test/test-conv2.c | 26 ++++++++++++++++++++------ libs/gamecode/test/test-conv3.c | 15 +++++++++++---- libs/gamecode/test/test-conv4.c | 22 ++++++++++++++++++---- libs/gamecode/test/test-conv5.c | 13 ++++++++++--- libs/gamecode/test/test-conv6.c | 26 ++++++++++++++++++++------ libs/gamecode/test/test-conv7.c | 15 +++++++++++---- 9 files changed, 133 insertions(+), 38 deletions(-) diff --git a/libs/gamecode/convert.py b/libs/gamecode/convert.py index dc4b36674..0474fbd8f 100644 --- a/libs/gamecode/convert.py +++ b/libs/gamecode/convert.py @@ -85,14 +85,25 @@ def expand_str(width, src, pref=""): for width in range(4): for src_type in range(8): for dst_type in range(8): - mode = convert_matrix[src_type][dst_type] - if not mode: - continue case = case_str(width, src_type, dst_type) cast = cast_str(width, src_type, dst_type) src = src_str(width, src_type, dst_type) dst = dst_str(width, src_type, dst_type) - if mode == 1: + mode = convert_matrix[src_type][dst_type] + if mode == 0: + if dst_type & 2 != src_type & 2: + continue + if dst_type & 2: + src = src_str(width, 2, 2) + dst = dst_str(width, 2, 2) + else: + src = src_str(width, 0, 0) + dst = dst_str(width, 0, 0) + if width == 2: + print(f"{case} VectorCopy(&{src},&{dst}); break;") + else: + print(f"{case} {dst} = {src}; break;") + elif mode == 1: if width == 0: print(f"{case} {dst} = {cast} {src}; break;") elif width == 2: diff --git a/libs/gamecode/test/test-conv0.c b/libs/gamecode/test/test-conv0.c index bfa492225..2f0533361 100644 --- a/libs/gamecode/test/test-conv0.c +++ b/libs/gamecode/test/test-conv0.c @@ -38,11 +38,11 @@ static pr_ivec4_t int_conv_expect[] = { { 256, 0, 0x7fffffff, 0}, //ulong { ~0, ~0, ~0, 0}, //bool64 { 0, ~0, 0, 0}, //bool64 - { 0, 0, 0, 0}, // int + { 5, -5, 0x80000000, 0x7fffffff}, // int { 1, -1, 0x80000000, 0x80000000}, // float undef? { 99, 0x80000000, 256, 0x7fffffff}, // long { 0x80000000, 0x80000000, 1, -1}, // double undef? - { 0, 0, 0, 0}, // uint + { 5, -5, 0x80000000, 0x7fffffff}, // uint { 1, 1, 1, 0}, // bool32 { 99, 0x80000000, 256, 0x7fffffff}, // ulong { 1, 1, 1, 0}, // bool64 @@ -58,13 +58,15 @@ static dstatement_t int_conv_1_statements[] = { { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, + { OP(1, 1, 1, OP_CONV), 0, 0000, 48 }, { OP(1, 1, 1, OP_CONV), 4, 0010, 52 }, { OP(2, 1, 1, OP_CONV), 8, 0020, 56 }, { OP(2, 1, 1, OP_CONV), 16, 0030, 60 }, + { OP(1, 1, 1, OP_CONV), 24, 0040, 64 }, { OP(1, 1, 1, OP_CONV), 28, 0050, 68 }, { OP(2, 1, 1, OP_CONV), 32, 0060, 72 }, { OP(2, 1, 1, OP_CONV), 40, 0070, 76 }, - { OP(1, 1, 1, OP_JUMP_A), -12, 0, 0 }, + { OP(1, 1, 1, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t int_conv_2_statements[] = { @@ -77,22 +79,28 @@ static dstatement_t int_conv_2_statements[] = { { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, + { OP(1, 1, 1, OP_CONV), 0, 0100, 48 }, { OP(1, 1, 1, OP_CONV), 4, 0110, 52 }, { OP(2, 1, 1, OP_CONV), 8, 0120, 56 }, { OP(2, 1, 1, OP_CONV), 16, 0130, 60 }, + { OP(1, 1, 1, OP_CONV), 24, 0140, 64 }, { OP(1, 1, 1, OP_CONV), 28, 0150, 68 }, { OP(2, 1, 1, OP_CONV), 32, 0160, 72 }, { OP(2, 1, 1, OP_CONV), 40, 0170, 76 }, - { OP(1, 1, 1, OP_JUMP_A), -12, 0, 0 }, + { OP(1, 1, 1, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t int_conv_3a_statements[] = { + { OP(1, 1, 1, OP_CONV), 0, 0200, 48 }, + { OP(1, 1, 1, OP_CONV), 3, 0200, 51 }, { OP(1, 1, 1, OP_CONV), 4, 0210, 52 }, { OP(1, 1, 1, OP_CONV), 7, 0010, 55 }, { OP(2, 1, 1, OP_CONV), 8, 0220, 56 }, { OP(2, 1, 1, OP_CONV), 14, 0020, 59 }, { OP(2, 1, 1, OP_CONV), 16, 0230, 60 }, { OP(2, 1, 1, OP_CONV), 22, 0030, 63 }, + { OP(1, 1, 1, OP_CONV), 24, 0240, 64 }, + { OP(1, 1, 1, OP_CONV), 27, 0240, 67 }, { OP(1, 1, 1, OP_CONV), 28, 0250, 68 }, { OP(1, 1, 1, OP_CONV), 31, 0050, 71 }, { OP(2, 1, 1, OP_CONV), 32, 0260, 72 }, @@ -102,12 +110,16 @@ static dstatement_t int_conv_3a_statements[] = { }; static dstatement_t int_conv_3b_statements[] = { + { OP(1, 1, 1, OP_CONV), 0, 0200, 48 }, + { OP(1, 1, 1, OP_CONV), 1, 0200, 49 }, { OP(1, 1, 1, OP_CONV), 4, 0010, 52 }, { OP(1, 1, 1, OP_CONV), 5, 0210, 53 }, { OP(2, 1, 1, OP_CONV), 8, 0020, 56 }, { OP(2, 1, 1, OP_CONV), 10, 0220, 57 }, { OP(2, 1, 1, OP_CONV), 16, 0030, 60 }, { OP(2, 1, 1, OP_CONV), 18, 0230, 61 }, + { OP(1, 1, 1, OP_CONV), 24, 0240, 64 }, + { OP(1, 1, 1, OP_CONV), 25, 0240, 65 }, { OP(1, 1, 1, OP_CONV), 28, 0050, 68 }, { OP(1, 1, 1, OP_CONV), 29, 0250, 69 }, { OP(2, 1, 1, OP_CONV), 32, 0060, 72 }, @@ -117,12 +129,14 @@ static dstatement_t int_conv_3b_statements[] = { }; static dstatement_t int_conv_4_statements[] = { + { OP(1, 1, 1, OP_CONV), 0, 0300, 48 }, { OP(1, 1, 1, OP_CONV), 4, 0310, 52 }, { OP(2, 1, 1, OP_CONV), 8, 0320, 56 }, { OP(2, 1, 1, OP_CONV), 16, 0330, 60 }, { OP(1, 1, 1, OP_CONV), 28, 0350, 68 }, { OP(2, 1, 1, OP_CONV), 32, 0360, 72 }, { OP(2, 1, 1, OP_CONV), 40, 0370, 76 }, + { OP(1, 1, 1, OP_CONV), 24, 0340, 64 }, }; test_t tests[] = { diff --git a/libs/gamecode/test/test-conv1.c b/libs/gamecode/test/test-conv1.c index 97c9735fe..6233b83f3 100644 --- a/libs/gamecode/test/test-conv1.c +++ b/libs/gamecode/test/test-conv1.c @@ -39,7 +39,7 @@ static pr_ivec4_t float_conv_expect[] = { { ~0, ~0, ~0, 0}, //bool64 { 0, ~0, 0, 0}, //bool64 { 0x40a00000, 0xc0a00000, 0xcf000000, 0x4f000000}, // int - { 0, 0, 0, 0}, // float + { 0x3fc00000, 0xbfc00000, 0x7149f2ca, 0xf149f2ca}, // float { 0xdf000000, 0x52c70000, 0x43800000, 0x4f000000}, // long { 0x7149f2ca, 0xf149f2ca, 0x3fc00000, 0xbfc00000}, // double { 0x40a00000, 0x4f800000, 0x4f000000, 0x4f000000}, // uint @@ -59,13 +59,14 @@ static dstatement_t float_conv_1_statements[] = { { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, { OP(1, 1, 1, OP_CONV), 0, 0001, 48 }, + { OP(1, 1, 1, OP_CONV), 4, 0011, 52 }, { OP(2, 1, 1, OP_CONV), 8, 0021, 56 }, { OP(2, 1, 1, OP_CONV), 16, 0031, 60 }, { OP(1, 1, 1, OP_CONV), 24, 0041, 64 }, { OP(1, 1, 1, OP_CONV), 28, 0051, 68 }, { OP(2, 1, 1, OP_CONV), 32, 0061, 72 }, { OP(2, 1, 1, OP_CONV), 40, 0071, 76 }, - { OP(1, 1, 1, OP_JUMP_A), -13, 0, 0 }, + { OP(1, 1, 1, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t float_conv_2_statements[] = { @@ -79,18 +80,21 @@ static dstatement_t float_conv_2_statements[] = { { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, { OP(1, 1, 1, OP_CONV), 0, 0101, 48 }, + { OP(1, 1, 1, OP_CONV), 4, 0111, 52 }, { OP(2, 1, 1, OP_CONV), 8, 0121, 56 }, { OP(2, 1, 1, OP_CONV), 16, 0131, 60 }, { OP(1, 1, 1, OP_CONV), 24, 0141, 64 }, { OP(1, 1, 1, OP_CONV), 28, 0151, 68 }, { OP(2, 1, 1, OP_CONV), 32, 0161, 72 }, { OP(2, 1, 1, OP_CONV), 40, 0171, 76 }, - { OP(1, 1, 1, OP_JUMP_A), -13, 0, 0 }, + { OP(1, 1, 1, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t float_conv_3a_statements[] = { { OP(1, 1, 1, OP_CONV), 0, 0201, 48 }, { OP(1, 1, 1, OP_CONV), 3, 0001, 51 }, + { OP(1, 1, 1, OP_CONV), 4, 0211, 52 }, + { OP(1, 1, 1, OP_CONV), 7, 0011, 55 }, { OP(2, 1, 1, OP_CONV), 8, 0221, 56 }, { OP(2, 1, 1, OP_CONV), 14, 0021, 59 }, { OP(2, 1, 1, OP_CONV), 16, 0231, 60 }, @@ -108,6 +112,8 @@ static dstatement_t float_conv_3a_statements[] = { static dstatement_t float_conv_3b_statements[] = { { OP(1, 1, 1, OP_CONV), 0, 0001, 48 }, { OP(1, 1, 1, OP_CONV), 1, 0201, 49 }, + { OP(1, 1, 1, OP_CONV), 4, 0011, 52 }, + { OP(1, 1, 1, OP_CONV), 5, 0211, 53 }, { OP(2, 1, 1, OP_CONV), 8, 0021, 56 }, { OP(2, 1, 1, OP_CONV), 10, 0221, 57 }, { OP(2, 1, 1, OP_CONV), 16, 0031, 60 }, @@ -124,6 +130,7 @@ static dstatement_t float_conv_3b_statements[] = { static dstatement_t float_conv_4_statements[] = { { OP(1, 1, 1, OP_CONV), 0, 0301, 48 }, + { OP(1, 1, 1, OP_CONV), 4, 0311, 52 }, { OP(2, 1, 1, OP_CONV), 8, 0321, 56 }, { OP(2, 1, 1, OP_CONV), 16, 0331, 60 }, { OP(1, 1, 1, OP_CONV), 24, 0341, 64 }, diff --git a/libs/gamecode/test/test-conv2.c b/libs/gamecode/test/test-conv2.c index 668f00724..f3a81a6ad 100644 --- a/libs/gamecode/test/test-conv2.c +++ b/libs/gamecode/test/test-conv2.c @@ -50,16 +50,16 @@ static pr_ivec4_t long_conv_expect[] = { { 0x80000000, 0xffffffff, 0x7fffffff, 0}, { 1, 0, -1, -1}, // float { 0, 0x80000000, 0, 0x80000000}, // undef? - { 0, 0, 0, 0}, // long - { 0, 0, 0, 0}, + { 99, 0x80000000, 0x80000000, 99}, // long + { 256, 0, 0x7fffffff, 0}, { 0, 0x80000000, 0, 0x80000000}, // double undef? { 1, 0, -1, -1}, { 5, 0, -5, 0}, // uint { 0x80000000, 0, 0x7fffffff, 0}, { 1, 0, 1, 0}, // bool32 { 1, 0, 0, 0}, - { 0, 0, 0, 0}, // ulong - { 0, 0, 0, 0}, + { 99, 0x80000000, 0x80000000, 99}, // ulong + { 256, 0, 0x7fffffff, 0}, { 1, 0, 1, 0}, // bool64 { 1, 0, 0, 0}, }; @@ -76,11 +76,13 @@ static dstatement_t long_conv_1_statements[] = { { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, { OP(1, 1, 2, OP_CONV), 0, 0002, 48 }, { OP(1, 1, 2, OP_CONV), 4, 0012, 56 }, + { OP(2, 1, 2, OP_CONV), 8, 0022, 64 }, { OP(2, 1, 2, OP_CONV), 16, 0032, 72 }, { OP(1, 1, 2, OP_CONV), 24, 0042, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0052, 88 }, + { OP(2, 1, 2, OP_CONV), 32, 0062, 96 }, { OP(2, 1, 2, OP_CONV), 40, 0072, 104 }, - { OP(0, 0, 0, OP_JUMP_A), -12, 0, 0 }, + { OP(0, 0, 0, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t long_conv_2_statements[] = { @@ -95,11 +97,13 @@ static dstatement_t long_conv_2_statements[] = { { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, { OP(1, 1, 2, OP_CONV), 0, 0102, 48 }, { OP(1, 1, 2, OP_CONV), 4, 0112, 56 }, + { OP(2, 1, 2, OP_CONV), 8, 0122, 64 }, { OP(2, 1, 2, OP_CONV), 16, 0132, 72 }, { OP(1, 1, 2, OP_CONV), 24, 0142, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0152, 88 }, + { OP(2, 1, 2, OP_CONV), 32, 0162, 96 }, { OP(2, 1, 2, OP_CONV), 40, 0172, 104 }, - { OP(0, 0, 0, OP_JUMP_A), -12, 0, 0 }, + { OP(0, 0, 0, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t long_conv_3a_statements[] = { @@ -107,12 +111,16 @@ static dstatement_t long_conv_3a_statements[] = { { OP(1, 1, 2, OP_CONV), 3, 0002, 54 }, { OP(1, 1, 2, OP_CONV), 4, 0212, 56 }, { OP(1, 1, 2, OP_CONV), 7, 0012, 62 }, + { OP(2, 1, 2, OP_CONV), 8, 0222, 64 }, + { OP(2, 1, 2, OP_CONV), 14, 0022, 70 }, { OP(2, 1, 2, OP_CONV), 16, 0232, 72 }, { OP(2, 1, 2, OP_CONV), 22, 0032, 78 }, { OP(1, 1, 2, OP_CONV), 24, 0242, 80 }, { OP(1, 1, 2, OP_CONV), 27, 0042, 86 }, { OP(1, 1, 2, OP_CONV), 28, 0252, 88 }, { OP(1, 1, 2, OP_CONV), 31, 0052, 94 }, + { OP(2, 1, 2, OP_CONV), 32, 0262, 96 }, + { OP(2, 1, 2, OP_CONV), 38, 0062, 102 }, { OP(2, 1, 2, OP_CONV), 40, 0272, 104 }, { OP(2, 1, 2, OP_CONV), 46, 0072, 110 }, }; @@ -122,12 +130,16 @@ static dstatement_t long_conv_3b_statements[] = { { OP(1, 1, 2, OP_CONV), 1, 0202, 50 }, { OP(1, 1, 2, OP_CONV), 4, 0012, 56 }, { OP(1, 1, 2, OP_CONV), 5, 0212, 58 }, + { OP(2, 1, 2, OP_CONV), 8, 0022, 64 }, + { OP(2, 1, 2, OP_CONV), 10, 0222, 66 }, { OP(2, 1, 2, OP_CONV), 16, 0032, 72 }, { OP(2, 1, 2, OP_CONV), 18, 0232, 74 }, { OP(1, 1, 2, OP_CONV), 24, 0042, 80 }, { OP(1, 1, 2, OP_CONV), 25, 0242, 82 }, { OP(1, 1, 2, OP_CONV), 28, 0052, 88 }, { OP(1, 1, 2, OP_CONV), 29, 0252, 90 }, + { OP(2, 1, 2, OP_CONV), 32, 0062, 96 }, + { OP(2, 1, 2, OP_CONV), 34, 0262, 98 }, { OP(2, 1, 2, OP_CONV), 40, 0072, 104 }, { OP(2, 1, 2, OP_CONV), 42, 0272, 106 }, }; @@ -135,9 +147,11 @@ static dstatement_t long_conv_3b_statements[] = { static dstatement_t long_conv_4_statements[] = { { OP(1, 1, 2, OP_CONV), 0, 0302, 48 }, { OP(1, 1, 2, OP_CONV), 4, 0312, 56 }, + { OP(2, 1, 2, OP_CONV), 8, 0322, 64 }, { OP(2, 1, 2, OP_CONV), 16, 0332, 72 }, { OP(1, 1, 2, OP_CONV), 24, 0342, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0352, 88 }, + { OP(2, 1, 2, OP_CONV), 32, 0362, 96 }, { OP(2, 1, 2, OP_CONV), 40, 0372, 104 }, }; diff --git a/libs/gamecode/test/test-conv3.c b/libs/gamecode/test/test-conv3.c index 038b20689..ea6989dda 100644 --- a/libs/gamecode/test/test-conv3.c +++ b/libs/gamecode/test/test-conv3.c @@ -52,8 +52,8 @@ static pr_ivec4_t double_conv_expect[] = { { 0x40000000, 0x46293e59, 0x40000000, 0xc6293e59}, { 0x00000000, 0xc3e00000, 0x00000000, 0x4258e000}, // long { 0x00000000, 0x40700000, 0xffc00000, 0x41dfffff}, - { 0, 0, 0, 0}, // double - { 0, 0, 0, 0}, + { 0x39a08cea, 0x46293e59, 0x39a08cea, 0xc6293e59}, // double + { 0, 0x3ff80000, 0, 0xbff80000}, { 0x00000000, 0x40140000, 0xff600000, 0x41efffff}, // uint { 0x00000000, 0x41e00000, 0xffc00000, 0x41dfffff}, { 0x00000000, 0x3ff00000, 0x00000000, 0x3ff00000}, // bool32 @@ -77,11 +77,12 @@ static dstatement_t double_conv_1_statements[] = { { OP(1, 1, 2, OP_CONV), 0, 0003, 48 }, { OP(1, 1, 2, OP_CONV), 4, 0013, 56 }, { OP(2, 1, 2, OP_CONV), 8, 0023, 64 }, + { OP(2, 1, 2, OP_CONV), 16, 0033, 72 }, { OP(1, 1, 2, OP_CONV), 24, 0043, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0053, 88 }, { OP(2, 1, 2, OP_CONV), 32, 0063, 96 }, { OP(2, 1, 2, OP_CONV), 40, 0073, 104 }, - { OP(0, 0, 0, OP_JUMP_A), -13, 0, 0 }, + { OP(0, 0, 0, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t double_conv_2_statements[] = { @@ -97,11 +98,12 @@ static dstatement_t double_conv_2_statements[] = { { OP(1, 1, 2, OP_CONV), 0, 0103, 48 }, { OP(1, 1, 2, OP_CONV), 4, 0113, 56 }, { OP(2, 1, 2, OP_CONV), 8, 0123, 64 }, + { OP(2, 1, 2, OP_CONV), 16, 0133, 72 }, { OP(1, 1, 2, OP_CONV), 24, 0143, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0153, 88 }, { OP(2, 1, 2, OP_CONV), 32, 0163, 96 }, { OP(2, 1, 2, OP_CONV), 40, 0173, 104 }, - { OP(0, 0, 0, OP_JUMP_A), -13, 0, 0 }, + { OP(0, 0, 0, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t double_conv_3a_statements[] = { @@ -111,6 +113,8 @@ static dstatement_t double_conv_3a_statements[] = { { OP(1, 1, 2, OP_CONV), 7, 0013, 62 }, { OP(2, 1, 2, OP_CONV), 8, 0223, 64 }, { OP(2, 1, 2, OP_CONV), 14, 0023, 70 }, + { OP(2, 1, 2, OP_CONV), 16, 0233, 72 }, + { OP(2, 1, 2, OP_CONV), 22, 0033, 78 }, { OP(1, 1, 2, OP_CONV), 24, 0243, 80 }, { OP(1, 1, 2, OP_CONV), 27, 0043, 86 }, { OP(1, 1, 2, OP_CONV), 28, 0253, 88 }, @@ -128,6 +132,8 @@ static dstatement_t double_conv_3b_statements[] = { { OP(1, 1, 2, OP_CONV), 5, 0213, 58 }, { OP(2, 1, 2, OP_CONV), 8, 0023, 64 }, { OP(2, 1, 2, OP_CONV), 10, 0223, 66 }, + { OP(2, 1, 2, OP_CONV), 16, 0033, 72 }, + { OP(2, 1, 2, OP_CONV), 18, 0233, 74 }, { OP(1, 1, 2, OP_CONV), 24, 0043, 80 }, { OP(1, 1, 2, OP_CONV), 25, 0243, 82 }, { OP(1, 1, 2, OP_CONV), 28, 0053, 88 }, @@ -142,6 +148,7 @@ static dstatement_t double_conv_4_statements[] = { { OP(1, 1, 2, OP_CONV), 0, 0303, 48 }, { OP(1, 1, 2, OP_CONV), 4, 0313, 56 }, { OP(2, 1, 2, OP_CONV), 8, 0323, 64 }, + { OP(2, 1, 2, OP_CONV), 16, 0333, 72 }, { OP(1, 1, 2, OP_CONV), 24, 0343, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0353, 88 }, { OP(2, 1, 2, OP_CONV), 32, 0363, 96 }, diff --git a/libs/gamecode/test/test-conv4.c b/libs/gamecode/test/test-conv4.c index 28f151339..0f7460a6a 100644 --- a/libs/gamecode/test/test-conv4.c +++ b/libs/gamecode/test/test-conv4.c @@ -38,11 +38,11 @@ static pr_ivec4_t uint_conv_expect[] = { { 256, 0, 0x7fffffff, 0}, //ulong { ~0, ~0, ~0, 0}, //bool64 { 0, ~0, 0, 0}, //bool64 - { 0, 0, 0, 0}, // int + { 5, -5, 0x80000000, 0x7fffffff}, // int { 1, 0xffffffff, 0, 0}, // float undef? { 99, 0x80000000, 256, 0x7fffffff}, // long { 0, 0, 1, 0xffffffff}, // double undef? - { 0, 0, 0, 0}, // uint + { 5, -5, 0x80000000, 0x7fffffff}, // uint { 1, 1, 1, 0}, // bool32 { 99, 0x80000000, 256, 0x7fffffff}, // ulong { 1, 1, 1, 0}, // bool64 @@ -58,13 +58,15 @@ static dstatement_t uint_conv_1_statements[] = { { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, + { OP(1, 1, 1, OP_CONV), 0, 0004, 48 }, { OP(1, 1, 1, OP_CONV), 4, 0014, 52 }, { OP(2, 1, 1, OP_CONV), 8, 0024, 56 }, { OP(2, 1, 1, OP_CONV), 16, 0034, 60 }, + { OP(1, 1, 1, OP_CONV), 24, 0044, 64 }, { OP(1, 1, 1, OP_CONV), 28, 0054, 68 }, { OP(2, 1, 1, OP_CONV), 32, 0064, 72 }, { OP(2, 1, 1, OP_CONV), 40, 0074, 76 }, - { OP(1, 1, 1, OP_JUMP_A), -12, 0, 0 }, + { OP(1, 1, 1, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t uint_conv_2_statements[] = { @@ -77,22 +79,28 @@ static dstatement_t uint_conv_2_statements[] = { { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, + { OP(1, 1, 1, OP_CONV), 0, 0104, 48 }, { OP(1, 1, 1, OP_CONV), 4, 0114, 52 }, { OP(2, 1, 1, OP_CONV), 8, 0124, 56 }, { OP(2, 1, 1, OP_CONV), 16, 0134, 60 }, + { OP(1, 1, 1, OP_CONV), 24, 0144, 64 }, { OP(1, 1, 1, OP_CONV), 28, 0154, 68 }, { OP(2, 1, 1, OP_CONV), 32, 0164, 72 }, { OP(2, 1, 1, OP_CONV), 40, 0174, 76 }, - { OP(1, 1, 1, OP_JUMP_A), -12, 0, 0 }, + { OP(1, 1, 1, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t uint_conv_3a_statements[] = { + { OP(1, 1, 1, OP_CONV), 0, 0204, 48 }, + { OP(1, 1, 1, OP_CONV), 3, 0004, 51 }, { OP(1, 1, 1, OP_CONV), 4, 0214, 52 }, { OP(1, 1, 1, OP_CONV), 7, 0014, 55 }, { OP(2, 1, 1, OP_CONV), 8, 0224, 56 }, { OP(2, 1, 1, OP_CONV), 14, 0024, 59 }, { OP(2, 1, 1, OP_CONV), 16, 0234, 60 }, { OP(2, 1, 1, OP_CONV), 22, 0034, 63 }, + { OP(1, 1, 1, OP_CONV), 24, 0244, 64 }, + { OP(1, 1, 1, OP_CONV), 27, 0044, 67 }, { OP(1, 1, 1, OP_CONV), 28, 0254, 68 }, { OP(1, 1, 1, OP_CONV), 31, 0054, 71 }, { OP(2, 1, 1, OP_CONV), 32, 0264, 72 }, @@ -102,12 +110,16 @@ static dstatement_t uint_conv_3a_statements[] = { }; static dstatement_t uint_conv_3b_statements[] = { + { OP(1, 1, 1, OP_CONV), 0, 0004, 48 }, + { OP(1, 1, 1, OP_CONV), 1, 0204, 49 }, { OP(1, 1, 1, OP_CONV), 4, 0014, 52 }, { OP(1, 1, 1, OP_CONV), 5, 0214, 53 }, { OP(2, 1, 1, OP_CONV), 8, 0024, 56 }, { OP(2, 1, 1, OP_CONV), 10, 0224, 57 }, { OP(2, 1, 1, OP_CONV), 16, 0034, 60 }, { OP(2, 1, 1, OP_CONV), 18, 0234, 61 }, + { OP(1, 1, 1, OP_CONV), 24, 0044, 64 }, + { OP(1, 1, 1, OP_CONV), 25, 0244, 65 }, { OP(1, 1, 1, OP_CONV), 28, 0054, 68 }, { OP(1, 1, 1, OP_CONV), 29, 0254, 69 }, { OP(2, 1, 1, OP_CONV), 32, 0064, 72 }, @@ -117,9 +129,11 @@ static dstatement_t uint_conv_3b_statements[] = { }; static dstatement_t uint_conv_4_statements[] = { + { OP(1, 1, 1, OP_CONV), 0, 0304, 48 }, { OP(1, 1, 1, OP_CONV), 4, 0314, 52 }, { OP(2, 1, 1, OP_CONV), 8, 0324, 56 }, { OP(2, 1, 1, OP_CONV), 16, 0334, 60 }, + { OP(1, 1, 1, OP_CONV), 24, 0344, 64 }, { OP(1, 1, 1, OP_CONV), 28, 0354, 68 }, { OP(2, 1, 1, OP_CONV), 32, 0364, 72 }, { OP(2, 1, 1, OP_CONV), 40, 0374, 76 }, diff --git a/libs/gamecode/test/test-conv5.c b/libs/gamecode/test/test-conv5.c index 796bd9cf6..3713cd159 100644 --- a/libs/gamecode/test/test-conv5.c +++ b/libs/gamecode/test/test-conv5.c @@ -43,7 +43,7 @@ static pr_ivec4_t bool32_conv_expect[] = { { -1, -1, -1, -1}, // long { -1, -1, -1, -1}, // double { -1, -1, -1, -1}, // uint - { 0, 0, 0, 0}, // bool32 + { ~0, 1, 0x80000000, 0}, // bool32 { -1, -1, -1, -1}, // ulong { -1, -1, -1, 0}, // bool64 }; @@ -63,9 +63,10 @@ static dstatement_t bool32_conv_1_statements[] = { { OP(2, 1, 1, OP_CONV), 8, 0025, 56 }, { OP(2, 1, 1, OP_CONV), 16, 0035, 60 }, { OP(1, 1, 1, OP_CONV), 24, 0045, 64 }, + { OP(1, 1, 1, OP_CONV), 28, 0055, 68 }, { OP(2, 1, 1, OP_CONV), 32, 0065, 72 }, { OP(2, 1, 1, OP_CONV), 40, 0075, 76 }, - { OP(1, 1, 1, OP_JUMP_A), -13, 0, 0 }, + { OP(1, 1, 1, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t bool32_conv_2_statements[] = { @@ -83,9 +84,10 @@ static dstatement_t bool32_conv_2_statements[] = { { OP(2, 1, 1, OP_CONV), 8, 0125, 56 }, { OP(2, 1, 1, OP_CONV), 16, 0135, 60 }, { OP(1, 1, 1, OP_CONV), 24, 0145, 64 }, + { OP(1, 1, 1, OP_CONV), 28, 0155, 68 }, { OP(2, 1, 1, OP_CONV), 32, 0165, 72 }, { OP(2, 1, 1, OP_CONV), 40, 0175, 76 }, - { OP(1, 1, 1, OP_JUMP_A), -13, 0, 0 }, + { OP(1, 1, 1, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t bool32_conv_3a_statements[] = { @@ -99,6 +101,8 @@ static dstatement_t bool32_conv_3a_statements[] = { { OP(2, 1, 1, OP_CONV), 22, 0035, 63 }, { OP(1, 1, 1, OP_CONV), 24, 0245, 64 }, { OP(1, 1, 1, OP_CONV), 27, 0045, 67 }, + { OP(1, 1, 1, OP_CONV), 28, 0255, 68 }, + { OP(1, 1, 1, OP_CONV), 31, 0055, 71 }, { OP(2, 1, 1, OP_CONV), 32, 0265, 72 }, { OP(2, 1, 1, OP_CONV), 38, 0065, 75 }, { OP(2, 1, 1, OP_CONV), 40, 0275, 76 }, @@ -116,6 +120,8 @@ static dstatement_t bool32_conv_3b_statements[] = { { OP(2, 1, 1, OP_CONV), 18, 0235, 61 }, { OP(1, 1, 1, OP_CONV), 24, 0045, 64 }, { OP(1, 1, 1, OP_CONV), 25, 0245, 65 }, + { OP(1, 1, 1, OP_CONV), 28, 0055, 68 }, + { OP(1, 1, 1, OP_CONV), 29, 0255, 69 }, { OP(2, 1, 1, OP_CONV), 32, 0065, 72 }, { OP(2, 1, 1, OP_CONV), 34, 0265, 73 }, { OP(2, 1, 1, OP_CONV), 40, 0075, 76 }, @@ -128,6 +134,7 @@ static dstatement_t bool32_conv_4_statements[] = { { OP(2, 1, 1, OP_CONV), 8, 0325, 56 }, { OP(2, 1, 1, OP_CONV), 16, 0335, 60 }, { OP(1, 1, 1, OP_CONV), 24, 0345, 64 }, + { OP(1, 1, 1, OP_CONV), 28, 0355, 68 }, { OP(2, 1, 1, OP_CONV), 32, 0365, 72 }, { OP(2, 1, 1, OP_CONV), 40, 0375, 76 }, }; diff --git a/libs/gamecode/test/test-conv6.c b/libs/gamecode/test/test-conv6.c index 58bafe43c..7fd62c1ac 100644 --- a/libs/gamecode/test/test-conv6.c +++ b/libs/gamecode/test/test-conv6.c @@ -50,16 +50,16 @@ static pr_ivec4_t ulong_conv_expect[] = { { 0x80000000, 0xffffffff, 0x7fffffff, 0}, { 1, 0, -1, -1}, // float { 0, 0, 0, 0x80000000}, // undef? - { 0, 0, 0, 0}, // long - { 0, 0, 0, 0}, + { 99, 0x80000000, 0x80000000, 99}, // long + { 256, 0, 0x7fffffff, 0}, { 0, 0, 0, 0x80000000}, // double undef? { 1, 0, -1, -1}, { 5, 0, -5, 0}, // uint { 0x80000000, 0, 0x7fffffff, 0}, { 1, 0, 1, 0}, // bool32 { 1, 0, 0, 0}, - { 0, 0, 0, 0}, // ulong - { 0, 0, 0, 0}, + { 99, 0x80000000, 0x80000000, 99}, // ulong + { 256, 0, 0x7fffffff, 0}, { 1, 0, 1, 0}, // bool64 { 1, 0, 0, 0}, }; @@ -76,11 +76,13 @@ static dstatement_t ulong_conv_1_statements[] = { { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, { OP(1, 1, 2, OP_CONV), 0, 0006, 48 }, { OP(1, 1, 2, OP_CONV), 4, 0016, 56 }, + { OP(2, 1, 2, OP_CONV), 8, 0026, 64 }, { OP(2, 1, 2, OP_CONV), 16, 0036, 72 }, { OP(1, 1, 2, OP_CONV), 24, 0046, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0056, 88 }, + { OP(2, 1, 2, OP_CONV), 32, 0066, 96 }, { OP(2, 1, 2, OP_CONV), 40, 0076, 104 }, - { OP(0, 0, 0, OP_JUMP_A), -12, 0, 0 }, + { OP(0, 0, 0, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t ulong_conv_2_statements[] = { @@ -95,11 +97,13 @@ static dstatement_t ulong_conv_2_statements[] = { { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, { OP(1, 1, 2, OP_CONV), 0, 0106, 48 }, { OP(1, 1, 2, OP_CONV), 4, 0116, 56 }, + { OP(2, 1, 2, OP_CONV), 8, 0126, 64 }, { OP(2, 1, 2, OP_CONV), 16, 0136, 72 }, { OP(1, 1, 2, OP_CONV), 24, 0146, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0156, 88 }, + { OP(2, 1, 2, OP_CONV), 32, 0166, 96 }, { OP(2, 1, 2, OP_CONV), 40, 0176, 104 }, - { OP(0, 0, 0, OP_JUMP_A), -12, 0, 0 }, + { OP(0, 0, 0, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t ulong_conv_3a_statements[] = { @@ -107,12 +111,16 @@ static dstatement_t ulong_conv_3a_statements[] = { { OP(1, 1, 2, OP_CONV), 3, 0006, 54 }, { OP(1, 1, 2, OP_CONV), 4, 0216, 56 }, { OP(1, 1, 2, OP_CONV), 7, 0016, 62 }, + { OP(2, 1, 2, OP_CONV), 8, 0226, 64 }, + { OP(2, 1, 2, OP_CONV), 14, 0026, 70 }, { OP(2, 1, 2, OP_CONV), 16, 0236, 72 }, { OP(2, 1, 2, OP_CONV), 22, 0036, 78 }, { OP(1, 1, 2, OP_CONV), 24, 0246, 80 }, { OP(1, 1, 2, OP_CONV), 27, 0046, 86 }, { OP(1, 1, 2, OP_CONV), 28, 0256, 88 }, { OP(1, 1, 2, OP_CONV), 31, 0056, 94 }, + { OP(2, 1, 2, OP_CONV), 32, 0266, 96 }, + { OP(2, 1, 2, OP_CONV), 38, 0066, 102 }, { OP(2, 1, 2, OP_CONV), 40, 0276, 104 }, { OP(2, 1, 2, OP_CONV), 46, 0076, 110 }, }; @@ -122,12 +130,16 @@ static dstatement_t ulong_conv_3b_statements[] = { { OP(1, 1, 2, OP_CONV), 1, 0206, 50 }, { OP(1, 1, 2, OP_CONV), 4, 0016, 56 }, { OP(1, 1, 2, OP_CONV), 5, 0216, 58 }, + { OP(2, 1, 2, OP_CONV), 8, 0026, 64 }, + { OP(2, 1, 2, OP_CONV), 10, 0226, 66 }, { OP(2, 1, 2, OP_CONV), 16, 0036, 72 }, { OP(2, 1, 2, OP_CONV), 18, 0236, 74 }, { OP(1, 1, 2, OP_CONV), 24, 0046, 80 }, { OP(1, 1, 2, OP_CONV), 25, 0246, 82 }, { OP(1, 1, 2, OP_CONV), 28, 0056, 88 }, { OP(1, 1, 2, OP_CONV), 29, 0256, 90 }, + { OP(2, 1, 2, OP_CONV), 32, 0066, 96 }, + { OP(2, 1, 2, OP_CONV), 34, 0266, 98 }, { OP(2, 1, 2, OP_CONV), 40, 0076, 104 }, { OP(2, 1, 2, OP_CONV), 42, 0276, 106 }, }; @@ -135,9 +147,11 @@ static dstatement_t ulong_conv_3b_statements[] = { static dstatement_t ulong_conv_4_statements[] = { { OP(1, 1, 2, OP_CONV), 0, 0306, 48 }, { OP(1, 1, 2, OP_CONV), 4, 0316, 56 }, + { OP(2, 1, 2, OP_CONV), 8, 0326, 64 }, { OP(2, 1, 2, OP_CONV), 16, 0336, 72 }, { OP(1, 1, 2, OP_CONV), 24, 0346, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0356, 88 }, + { OP(2, 1, 2, OP_CONV), 32, 0366, 96 }, { OP(2, 1, 2, OP_CONV), 40, 0376, 104 }, }; diff --git a/libs/gamecode/test/test-conv7.c b/libs/gamecode/test/test-conv7.c index 9612b1ee0..c8f9354c0 100644 --- a/libs/gamecode/test/test-conv7.c +++ b/libs/gamecode/test/test-conv7.c @@ -60,8 +60,8 @@ static pr_ivec4_t bool64_conv_expect[] = { { 0xffffffff, 0xffffffff, 0, 0}, { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, // ulong { 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}, - { 0, 0, 0, 0}, // bool64 - { 0, 0, 0, 0}, + { ~0, ~0, ~0, 0}, // bool64 + { 0, ~0, 0, 0}, }; static dstatement_t bool64_conv_1_statements[] = { @@ -81,7 +81,8 @@ static dstatement_t bool64_conv_1_statements[] = { { OP(1, 1, 2, OP_CONV), 24, 0047, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0057, 88 }, { OP(2, 1, 2, OP_CONV), 32, 0067, 96 }, - { OP(0, 0, 0, OP_JUMP_A), -13, 0, 0 }, + { OP(2, 1, 2, OP_CONV), 40, 0077, 104 }, + { OP(0, 0, 0, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t bool64_conv_2_statements[] = { @@ -101,7 +102,8 @@ static dstatement_t bool64_conv_2_statements[] = { { OP(1, 1, 2, OP_CONV), 24, 0147, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0157, 88 }, { OP(2, 1, 2, OP_CONV), 32, 0167, 96 }, - { OP(0, 0, 0, OP_JUMP_A), -13, 0, 0 }, + { OP(2, 1, 2, OP_CONV), 40, 0177, 104 }, + { OP(0, 0, 0, OP_JUMP_A), -14, 0, 0 }, }; static dstatement_t bool64_conv_3a_statements[] = { @@ -119,6 +121,8 @@ static dstatement_t bool64_conv_3a_statements[] = { { OP(1, 1, 2, OP_CONV), 31, 0057, 94 }, { OP(2, 1, 2, OP_CONV), 32, 0267, 96 }, { OP(2, 1, 2, OP_CONV), 38, 0067, 102 }, + { OP(2, 1, 2, OP_CONV), 40, 0277, 104 }, + { OP(2, 1, 2, OP_CONV), 46, 0077, 110 }, }; static dstatement_t bool64_conv_3b_statements[] = { @@ -136,6 +140,8 @@ static dstatement_t bool64_conv_3b_statements[] = { { OP(1, 1, 2, OP_CONV), 29, 0257, 90 }, { OP(2, 1, 2, OP_CONV), 32, 0067, 96 }, { OP(2, 1, 2, OP_CONV), 34, 0267, 98 }, + { OP(2, 1, 2, OP_CONV), 40, 0077, 104 }, + { OP(2, 1, 2, OP_CONV), 42, 0277, 106 }, }; static dstatement_t bool64_conv_4_statements[] = { @@ -146,6 +152,7 @@ static dstatement_t bool64_conv_4_statements[] = { { OP(1, 1, 2, OP_CONV), 24, 0347, 80 }, { OP(1, 1, 2, OP_CONV), 28, 0357, 88 }, { OP(2, 1, 2, OP_CONV), 32, 0367, 96 }, + { OP(2, 1, 2, OP_CONV), 40, 0377, 104 }, }; test_t tests[] = { From 11e89c8c97769f984a305f096622045d16b08f6d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 15 Jan 2022 16:07:11 +0900 Subject: [PATCH 108/360] [gamecode] Add tests for lea --- libs/gamecode/test/Makemodule.am | 6 +++++ libs/gamecode/test/test-lea.c | 41 ++++++++++++++++++++++++++++++++ 2 files changed, 47 insertions(+) create mode 100644 libs/gamecode/test/test-lea.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index cdc0824a6..364ebfea6 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -11,6 +11,7 @@ libs_gamecode_tests = \ libs/gamecode/test/test-double \ libs/gamecode/test/test-float \ libs/gamecode/test/test-int \ + libs/gamecode/test/test-lea \ libs/gamecode/test/test-load \ libs/gamecode/test/test-long \ libs/gamecode/test/test-mem \ @@ -91,6 +92,11 @@ libs_gamecode_test_test_int_SOURCES= \ libs_gamecode_test_test_int_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_int_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_lea_SOURCES= \ + libs/gamecode/test/test-lea.c +libs_gamecode_test_test_lea_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_lea_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_load_SOURCES= \ libs/gamecode/test/test-load.c libs_gamecode_test_test_load_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-lea.c b/libs/gamecode/test/test-lea.c new file mode 100644 index 000000000..36de277ff --- /dev/null +++ b/libs/gamecode/test/test-lea.c @@ -0,0 +1,41 @@ +#include "head.c" + +static pr_int_t lea_globals_init[] = { + // pointers + 24, 26, 28, 29, + 32, -4, -2, 0, + 1, 4, 0xdeadbeef, 0xfeedf00d, + + 0, 0, 0, 0, 0, +}; + +static pr_int_t lea_globals_expect[] = { + // pointers + 24, 26, 28, 29, + 32, -4, -2, 0, + 1, 4, 0xdeadbeef, 0xfeedf00d, + + 7, 29, 34, 26, 88, +}; + +static dstatement_t lea_statements[] = { + {OP(0, 0, 0, OP_LEA_A), 7, 9, 12}, + {OP(0, 0, 0, OP_LEA_B), 3, 8, 13}, + {OP(0, 0, 0, OP_LEA_C), 2, 6, 14}, + {OP(0, 0, 0, OP_LEA_D), 2, 6, 15}, + {OP(0, 0, 0, OP_LEA_E), 4, 2, 16}, +}; + +test_t tests[] = { + { + .desc = "lea", + .num_globals = num_globals (lea_globals_init, lea_globals_expect), + .num_statements = num_statements (lea_statements), + .statements = lea_statements, + .init_globals = lea_globals_init, + .expect_globals = lea_globals_expect, + .edict_area = 28, + }, +}; + +#include "main.c" From e133de8c89a3245a2164bc2da0b8779c60bd6d96 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 15 Jan 2022 16:27:46 +0900 Subject: [PATCH 109/360] [gamecode] Drop B addressing for lea When creating the tests for lea, I noticed that B was yet another simple assign, so I decided it was best to drop it and move E into its place (freeing up another instruction). --- libs/gamecode/opcodes.py | 16 ++---- libs/gamecode/pr_exec.c | 92 ++++++++++++++--------------------- libs/gamecode/test/test-lea.c | 11 ++--- 3 files changed, 44 insertions(+), 75 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 0596636c7..3c8e85cd0 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -25,7 +25,7 @@ bitmap_txt = """ 1 1010 d1xx 1 1011 00mm lea 1 1011 01ss any -1 1011 0100 lea_e +1 1011 0100 1 1011 10ss all 1 1011 1000 pushregs 1 1011 11ss none @@ -176,24 +176,15 @@ lea_formats = { "widths": "0, 0, 1", "types": "ev_pointer, ev_pointer, ev_pointer", "args": { - "op_mode": "ABCD", + "op_mode": "AECD", "lea_fmt": [ "%ga, %gc", - "*%Ga, %gc", + "%Ga.%Gb(%Ea), %gc", "*(%Ga + %sb), %gc", "*(%Ga + %Gb), %gc", ], }, } -lea_e_formats = { - "opcode": "OP_LEA_E", - "mnemonic": "lea", - "opname": "lea", - "format": "{load_fmt[0]}", - "format": "%Ga.%Gb(%Ea), %gc", - "types": "ev_entity, ev_field, ev_pointer", - "widths": "0, 0, 1", -} load_formats = { "opcode": "OP_LOAD_{op_mode[mm]}_{ss+1}", "mnemonic": "load", @@ -461,7 +452,6 @@ group_map = { "compare2": compare2_formats, "convert": convert_formats, "lea": lea_formats, - "lea_e": lea_e_formats, "load": load_formats, "mathops": mathops_formats, "memset": memset_formats, diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index abe934815..f8d31a6ec 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1735,41 +1735,10 @@ exit_program: #define STK(type) (*((pr_##type##_t *) (stk))) static pr_type_t * -pr_entity_mode (progs_t *pr, const dstatement_t *st, int shift) +pr_address_mode (progs_t *pr, const dstatement_t *st, int mm_ind) { pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, B); - int mm_ind = (st->op >> shift) & 3; - pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; - pointer_t mm_offs = 0; - - switch (mm_ind) { - case 0: - // entity.field (equivalent to OP_LOAD_t_v6p) - mm_offs = edict_area + OPA(uint) + OPB(uint); - break; - case 1: - // simple pointer dereference: *a - mm_offs = OPA(uint); - break; - case 2: - // constant indexed pointer: *a + b (supports -ve offset) - mm_offs = OPA(uint) + (short) st->b; - break; - case 3: - // variable indexed pointer: *a + *b (supports -ve offset) - mm_offs = OPA(uint) + OPB(int); - break; - } - return pr->pr_globals + mm_offs; -} - -static pr_type_t * -pr_address_mode (progs_t *pr, const dstatement_t *st, int shift) -{ - pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); - pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, B); - int mm_ind = (st->op >> shift) & 3; pointer_t mm_offs = 0; switch (mm_ind) { @@ -1789,6 +1758,11 @@ pr_address_mode (progs_t *pr, const dstatement_t *st, int shift) // variable indexed pointer: *a + *b (supports -ve offset) mm_offs = OPA(uint) + OPB(int); break; + case 4: + // entity.field (equivalent to OP_LOAD_t_v6p) + pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; + mm_offs = edict_area + OPA(uint) + OPB(uint); + break; } return pr->pr_globals + mm_offs; } @@ -2758,31 +2732,43 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) switch (st_op) { // 0 0000 case OP_LOAD_E_1: + mm = pr_address_mode (pr, st, 4); + OPC(int) = MM(int); + break; case OP_LOAD_B_1: case OP_LOAD_C_1: case OP_LOAD_D_1: - mm = pr_entity_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_LOAD_E_1) >> 2); OPC(int) = MM(int); break; case OP_LOAD_E_2: + mm = pr_address_mode (pr, st, 4); + OPC(ivec2) = MM(ivec2); + break; case OP_LOAD_B_2: case OP_LOAD_C_2: case OP_LOAD_D_2: - mm = pr_entity_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_LOAD_E_2) >> 2); OPC(ivec2) = MM(ivec2); break; case OP_LOAD_E_3: + mm = pr_address_mode (pr, st, 4); + VectorCopy (&MM(int), &OPC(int)); + break; case OP_LOAD_B_3: case OP_LOAD_C_3: case OP_LOAD_D_3: - mm = pr_entity_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_LOAD_E_3) >> 2); VectorCopy (&MM(int), &OPC(int)); break; case OP_LOAD_E_4: + mm = pr_address_mode (pr, st, 4); + OPC(ivec4) = MM(ivec4); + break; case OP_LOAD_B_4: case OP_LOAD_C_4: case OP_LOAD_D_4: - mm = pr_entity_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_LOAD_E_4) >> 2); OPC(ivec4) = MM(ivec4); break; // 0 0001 @@ -2790,28 +2776,28 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_STORE_B_1: case OP_STORE_C_1: case OP_STORE_D_1: - mm = pr_address_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_STORE_A_1) >> 2); MM(int) = OPC(int); break; case OP_STORE_A_2: case OP_STORE_B_2: case OP_STORE_C_2: case OP_STORE_D_2: - mm = pr_address_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_STORE_A_2) >> 2); MM(ivec2) = OPC(ivec2); break; case OP_STORE_A_3: case OP_STORE_B_3: case OP_STORE_C_3: case OP_STORE_D_3: - mm = pr_address_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_STORE_A_3) >> 2); VectorCopy (&OPC(int), &MM(int)); break; case OP_STORE_A_4: case OP_STORE_B_4: case OP_STORE_C_4: case OP_STORE_D_4: - mm = pr_address_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_STORE_A_4) >> 2); MM(ivec4) = OPC(ivec4); break; // 0 0010 @@ -2819,7 +2805,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_PUSH_B_1: case OP_PUSH_C_1: case OP_PUSH_D_1: - mm = pr_address_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_PUSH_A_1) >> 2); stk = pr_stack_push (pr); STK(int) = MM(int); break; @@ -2827,7 +2813,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_PUSH_B_2: case OP_PUSH_C_2: case OP_PUSH_D_2: - mm = pr_address_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_PUSH_A_2) >> 2); stk = pr_stack_push (pr); STK(ivec2) = MM(ivec2); break; @@ -2835,7 +2821,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_PUSH_B_3: case OP_PUSH_C_3: case OP_PUSH_D_3: - mm = pr_address_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_PUSH_A_3) >> 2); stk = pr_stack_push (pr); VectorCopy (&MM(int), &STK(int)); break; @@ -2843,7 +2829,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_PUSH_B_4: case OP_PUSH_C_4: case OP_PUSH_D_4: - mm = pr_address_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_PUSH_A_4) >> 2); stk = pr_stack_push (pr); STK(ivec4) = MM(ivec4); break; @@ -2852,7 +2838,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_POP_B_1: case OP_POP_C_1: case OP_POP_D_1: - mm = pr_address_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_POP_A_1) >> 2); stk = pr_stack_pop (pr); MM(int) = STK(int); break; @@ -2860,7 +2846,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_POP_B_2: case OP_POP_C_2: case OP_POP_D_2: - mm = pr_address_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_POP_A_2) >> 2); stk = pr_stack_pop (pr); MM(ivec2) = STK(ivec2); break; @@ -2868,7 +2854,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_POP_B_3: case OP_POP_C_3: case OP_POP_D_3: - mm = pr_address_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_POP_A_3) >> 2); stk = pr_stack_pop (pr); VectorCopy (&STK(int), &MM(int)); break; @@ -2876,7 +2862,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_POP_B_4: case OP_POP_C_4: case OP_POP_D_4: - mm = pr_address_mode (pr, st, 2); + mm = pr_address_mode (pr, st, (st_op - OP_POP_A_4) >> 2); stk = pr_stack_pop (pr); MM(ivec4) = STK(ivec4); break; @@ -3342,19 +3328,13 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) // spare // 1 1011 case OP_LEA_A: - case OP_LEA_B: case OP_LEA_C: case OP_LEA_D: - mm = pr_address_mode (pr, st, 0); + mm = pr_address_mode (pr, st, (st_op - OP_LEA_A)); op_c->pointer_var = mm - pr->pr_globals; break; case OP_LEA_E: - // ensures OP_LEA_E is compatible with OP_LOAD_E_n and thus - // with pr_entity_mode - mm = __builtin_choose_expr ( - (OP_LEA_E & 3) == 0, - pr_entity_mode (pr, st, 0), - (void) 0); + mm = pr_address_mode (pr, st, 4); op_c->pointer_var = mm - pr->pr_globals; break; case OP_ANY_2: diff --git a/libs/gamecode/test/test-lea.c b/libs/gamecode/test/test-lea.c index 36de277ff..1a4f159f7 100644 --- a/libs/gamecode/test/test-lea.c +++ b/libs/gamecode/test/test-lea.c @@ -6,7 +6,7 @@ static pr_int_t lea_globals_init[] = { 32, -4, -2, 0, 1, 4, 0xdeadbeef, 0xfeedf00d, - 0, 0, 0, 0, 0, + 0, 0, 0, 0, }; static pr_int_t lea_globals_expect[] = { @@ -15,15 +15,14 @@ static pr_int_t lea_globals_expect[] = { 32, -4, -2, 0, 1, 4, 0xdeadbeef, 0xfeedf00d, - 7, 29, 34, 26, 88, + 7, 34, 26, 88, }; static dstatement_t lea_statements[] = { {OP(0, 0, 0, OP_LEA_A), 7, 9, 12}, - {OP(0, 0, 0, OP_LEA_B), 3, 8, 13}, - {OP(0, 0, 0, OP_LEA_C), 2, 6, 14}, - {OP(0, 0, 0, OP_LEA_D), 2, 6, 15}, - {OP(0, 0, 0, OP_LEA_E), 4, 2, 16}, + {OP(0, 0, 0, OP_LEA_C), 2, 6, 13}, + {OP(0, 0, 0, OP_LEA_D), 2, 6, 14}, + {OP(0, 0, 0, OP_LEA_E), 4, 2, 15}, }; test_t tests[] = { From a14b9f8252068b606f66ea39b2cdfec23bf2a6fd Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 15 Jan 2022 16:39:52 +0900 Subject: [PATCH 110/360] [gamecode] Move the lea block It just feels better with it being close the load/store etc --- libs/gamecode/opcodes.py | 3 ++- libs/gamecode/pr_exec.c | 22 +++++++++++----------- 2 files changed, 13 insertions(+), 12 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 3c8e85cd0..5e491510b 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -11,6 +11,7 @@ bitmap_txt = """ 0 0101 1100 return (size in st->c) 0 0110 0nnn +0 0110 10mm lea 0 0110 1100 convert (conversion mode in st->b) 0 0110 1101 with (mode in st->a, value in st->b, reg in st->c) 0 0110 111t state @@ -23,7 +24,7 @@ bitmap_txt = """ 1 1001 t1ss scale 1 1001 t100 swizzle 1 1010 d1xx -1 1011 00mm lea +1 1011 00nn 1 1011 01ss any 1 1011 0100 1 1011 10ss all diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index f8d31a6ec..80f9161af 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -2961,7 +2961,16 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) break; // 0 0110 // 0nnn spare - // 10nn spare + case OP_LEA_A: + case OP_LEA_C: + case OP_LEA_D: + mm = pr_address_mode (pr, st, (st_op - OP_LEA_A)); + op_c->pointer_var = mm - pr->pr_globals; + break; + case OP_LEA_E: + mm = pr_address_mode (pr, st, 4); + op_c->pointer_var = mm - pr->pr_globals; + break; case OP_CONV: switch (st->b) { #include "libs/gamecode/pr_convert.cinc" @@ -3327,16 +3336,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OP_cmp_T (GT, U, long, lvec2, lvec4, >, ulong, ulvec2, ulvec4); // spare // 1 1011 - case OP_LEA_A: - case OP_LEA_C: - case OP_LEA_D: - mm = pr_address_mode (pr, st, (st_op - OP_LEA_A)); - op_c->pointer_var = mm - pr->pr_globals; - break; - case OP_LEA_E: - mm = pr_address_mode (pr, st, 4); - op_c->pointer_var = mm - pr->pr_globals; - break; + // 00nn spare case OP_ANY_2: OPC(int) = any2i (OPA(ivec2)); break; From 38ab0f0243b754e8a7d94e4f9aeea8aae6e794a4 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 15 Jan 2022 16:51:59 +0900 Subject: [PATCH 111/360] [gamecode] Move pushregs and popregs into with This frees up another two instructions. --- libs/gamecode/opcodes.py | 4 +- libs/gamecode/pr_exec.c | 101 ++++++++++++++++++++++----------------- 2 files changed, 58 insertions(+), 47 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 5e491510b..ceccba4a7 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -28,9 +28,9 @@ bitmap_txt = """ 1 1011 01ss any 1 1011 0100 1 1011 10ss all -1 1011 1000 pushregs +1 1011 1000 1 1011 11ss none -1 1011 1100 popregs +1 1011 1100 1 1101 01oo move 1 1101 11oo memset 1 1110 d1xx diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 80f9161af..b3a4afae9 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1861,42 +1861,6 @@ pr_jump_mode (progs_t *pr, const dstatement_t *st) return jump_offs - 1; // for st++ } -static pr_pointer_t __attribute__((pure)) -pr_with (progs_t *pr, const dstatement_t *st) -{ - pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; - pr_type_t *op_b = pr->pr_globals + PR_BASE (pr, st, B) + st->b; - - switch (st->a) { - // fixed offset - case 0: - // hard-0 base - return st->b; - case 1: - // relative to current base - return PR_BASE (pr, st, B) + st->b; - case 2: - // relative to stack (-ve offset) - return *pr->globals.stack + (pr_short_t) st->b; - case 3: - // relative to edict_area (+ve only) - return edict_area + st->b; - - case 4: - // hard-0 base - return pr->pr_globals[st->b].pointer_var; - case 5: - return OPB(pointer); - case 6: - // relative to stack (-ve offset) - return *pr->globals.stack + OPB(int); - case 7: - // relative to edict_area (+ve only) - return edict_area + OPB(uint); - } - PR_RunError (pr, "Invalid with index: %u", st->a); -} - static pr_type_t * pr_stack_push (progs_t *pr) { @@ -1923,6 +1887,59 @@ pr_stack_pop (progs_t *pr) return stk; } +static void +pr_with (progs_t *pr, const dstatement_t *st) +{ + pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; + pr_type_t *op_b = pr->pr_globals + PR_BASE (pr, st, B) + st->b; + pr_type_t *stk; + + switch (st->a) { + // fixed offset + case 0: + // hard-0 base + pr->pr_bases[st->c & 3] = st->b; + return; + case 1: + // relative to current base + pr->pr_bases[st->c & 3] = PR_BASE (pr, st, B) + st->b; + return; + case 2: + // relative to stack (-ve offset) + pr->pr_bases[st->c & 3] = *pr->globals.stack + (pr_short_t) st->b; + return; + case 3: + // relative to edict_area (+ve only) + pr->pr_bases[st->c & 3] = edict_area + st->b; + return; + + case 4: + // hard-0 base + pr->pr_bases[st->c & 3] = pr->pr_globals[st->b].pointer_var; + return; + case 5: + pr->pr_bases[st->c & 3] = OPB(pointer); + return; + case 6: + // relative to stack (-ve offset) + pr->pr_bases[st->c & 3] = *pr->globals.stack + OPB(int); + return; + case 7: + // relative to edict_area (+ve only) + pr->pr_bases[st->c & 3] = edict_area + OPB(uint); + return; + case 8: + stk = pr_stack_push (pr); + STK(uivec4) = pr->pr_bases; + return; + case 9: + stk = pr_stack_pop (pr); + pr->pr_bases = STK(uivec4); + return; + } + PR_RunError (pr, "Invalid with index: %u", st->a); +} + static pr_ivec4_t pr_swizzle_f (pr_ivec4_t vec, pr_ushort_t swiz) { @@ -2980,7 +2997,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) } break; case OP_WITH: - pr->pr_bases[st->c & 3] = pr_with (pr, st); + pr_with (pr, st); break; case OP_STATE_ft: { @@ -3349,10 +3366,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_ANY_4: OPC(int) = any4i (OPA(ivec4)); break; - case OP_PUSHREGS: - stk = pr_stack_push (pr); - STK(uivec4) = pr->pr_bases; - break; + // spare case OP_ALL_2: OPC(int) = all2i (OPA(ivec2)); break; @@ -3366,10 +3380,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_ALL_4: OPC(int) = all4i (OPA(ivec4)); break; - case OP_POPREGS: - stk = pr_stack_pop (pr); - pr->pr_bases = STK(uivec4); - break; + // spare case OP_NONE_2: OPC(int) = none2i (OPA(ivec2)); break; From 49dcd5ef4092a08753e785ec08345cb59fddd7a5 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 15 Jan 2022 18:44:11 +0900 Subject: [PATCH 112/360] [gamecode] Add tests for the with instruction(s) While mode 4 was tested a lot, none of the rest were. Also added a full reset instruction. --- libs/gamecode/pr_exec.c | 30 +-- libs/gamecode/test/Makemodule.am | 16 +- libs/gamecode/test/test-with.c | 307 +++++++++++++++++++++++++++++++ 3 files changed, 337 insertions(+), 16 deletions(-) create mode 100644 libs/gamecode/test/test-with.c diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index b3a4afae9..69d9c0f6f 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1893,49 +1893,57 @@ pr_with (progs_t *pr, const dstatement_t *st) pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; pr_type_t *op_b = pr->pr_globals + PR_BASE (pr, st, B) + st->b; pr_type_t *stk; + pr_uint_t *base = &pr->pr_bases[st->c & 3]; switch (st->a) { // fixed offset case 0: // hard-0 base - pr->pr_bases[st->c & 3] = st->b; + *base = st->b; return; case 1: - // relative to current base - pr->pr_bases[st->c & 3] = PR_BASE (pr, st, B) + st->b; + // relative to current base (-ve offset) + *base = PR_BASE (pr, st, B) + (pr_short_t) st->b; return; case 2: // relative to stack (-ve offset) - pr->pr_bases[st->c & 3] = *pr->globals.stack + (pr_short_t) st->b; + *base = *pr->globals.stack + (pr_short_t) st->b; return; case 3: - // relative to edict_area (+ve only) - pr->pr_bases[st->c & 3] = edict_area + st->b; + // relative to edict_area (only +ve) + *base = edict_area + st->b; return; case 4: // hard-0 base - pr->pr_bases[st->c & 3] = pr->pr_globals[st->b].pointer_var; + *base = pr->pr_globals[st->b].pointer_var; return; case 5: - pr->pr_bases[st->c & 3] = OPB(pointer); + *base = OPB(pointer); return; case 6: // relative to stack (-ve offset) - pr->pr_bases[st->c & 3] = *pr->globals.stack + OPB(int); + *base = *pr->globals.stack + OPB(int); return; case 7: - // relative to edict_area (+ve only) - pr->pr_bases[st->c & 3] = edict_area + OPB(uint); + // relative to edict_area (only +ve) + *base = edict_area + OPB(uint); return; + case 8: + // pushregs stk = pr_stack_push (pr); STK(uivec4) = pr->pr_bases; return; case 9: + // popregs stk = pr_stack_pop (pr); pr->pr_bases = STK(uivec4); return; + case 10: + // reset + pr->pr_bases = (pr_uivec4_t) {}; + return; } PR_RunError (pr, "Invalid with index: %u", st->a); } diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index 364ebfea6..8fc813622 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -20,7 +20,8 @@ libs_gamecode_tests = \ libs/gamecode/test/test-store \ libs/gamecode/test/test-string \ libs/gamecode/test/test-unsigned \ - libs/gamecode/test/test-vector + libs/gamecode/test/test-vector \ + libs/gamecode/test/test-with TESTS += $(libs_gamecode_tests) @@ -132,12 +133,17 @@ libs_gamecode_test_test_string_SOURCES= \ libs_gamecode_test_test_string_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_string_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_unsigned_SOURCES= \ + libs/gamecode/test/test-unsigned.c +libs_gamecode_test_test_unsigned_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_unsigned_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_vector_SOURCES= \ libs/gamecode/test/test-vector.c libs_gamecode_test_test_vector_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_vector_DEPENDENCIES= $(test_gamecode_libs) -libs_gamecode_test_test_unsigned_SOURCES= \ - libs/gamecode/test/test-unsigned.c -libs_gamecode_test_test_unsigned_LDADD= $(test_gamecode_libs) -libs_gamecode_test_test_unsigned_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_with_SOURCES= \ + libs/gamecode/test/test-with.c +libs_gamecode_test_test_with_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_with_DEPENDENCIES= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-with.c b/libs/gamecode/test/test-with.c new file mode 100644 index 000000000..f86637360 --- /dev/null +++ b/libs/gamecode/test/test-with.c @@ -0,0 +1,307 @@ +#include "head.c" + +#include "QF/mathlib.h" + +#define DB 0xdeadbeef + +static pr_ivec4_t pushregs_init[] = { + { DB, DB, DB, DB}, +}; + +static pr_ivec4_t pushregs_expect[] = { + { 0, 0, 0, 0}, // initial base regs should all be 0 +}; + +static dstatement_t pushregs_statements[] = { + { OP(0, 0, 0, OP_WITH), 8, 0, 0 }, // pushregs + { OP(0, 0, 0, OP_POP_A_4), 0, 0, 0 }, +}; + +static pr_ivec4_t popregs_init[] = { + { 4, 5, 6, 7}, + { DB, DB, DB, DB}, +}; + +static pr_ivec4_t popregs_expect[] = { + { 4, 5, 6, 7}, + { 7, 6, 5, 4}, +}; + +static dstatement_t popregs_statements[] = { + { OP(0, 0, 0, OP_PUSH_A_4), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 9, 0, 0 }, // popregs + { OP(3, 0, 0, OP_LEA_A), 0, 0, 0 }, + { OP(2, 0, 1, OP_LEA_A), 0, 0, 0 }, + { OP(1, 0, 2, OP_LEA_A), 0, 0, 0 }, + { OP(0, 0, 3, OP_LEA_A), 0, 0, 0 }, +}; + +static pr_ivec4_t with_0_init[] = { + { 4, 5, 6, 7}, + { DB, DB, DB, DB}, + { DB, DB, DB, DB}, + { DB, DB, DB, DB}, +}; + +static pr_ivec4_t with_0_expect[] = { + { 4, 5, 6, 7}, + { 0, 1, 6, 7}, + { 4, 5, 0, 1}, + { 0, 0, 0, 0}, +}; + +static dstatement_t with_0_statements[] = { + { OP(0, 0, 0, OP_PUSH_A_4), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 9, 0, 0 }, // popregs + { OP(0, 0, 0, OP_WITH), 0, 0, 0 }, // set reg 0 to 0 + { OP(0, 0, 0, OP_WITH), 0, 1, 1 }, // set reg 1 to 1 + { OP(0, 0, 0, OP_WITH), 8, 0, 0 }, // pushregs + { OP(0, 0, 0, OP_POP_A_4), 4, 0, 0 }, + { OP(0, 0, 0, OP_PUSH_A_4), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 9, 0, 0 }, // popregs + { OP(0, 0, 0, OP_WITH), 0, 0, 2 }, // set reg 2 to 0 + { OP(0, 0, 0, OP_WITH), 0, 1, 3 }, // set reg 3 to 1 + { OP(0, 0, 0, OP_WITH), 8, 0, 0 }, // pushregs + { OP(2, 0, 0, OP_POP_A_4), 8, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 10, 0, 0 }, // reset + { OP(0, 0, 0, OP_WITH), 8, 0, 0 }, // pushregs + { OP(2, 0, 0, OP_POP_A_4), 12, 0, 0 }, +}; + +static pr_ivec4_t with_1_init[] = { + { 4, 5, 6, 7}, + { DB, DB, DB, DB}, +}; + +static pr_ivec4_t with_1_expect[] = { + { 4, 5, 6, 7}, + { 0, 4, 6, 2}, +}; + +static dstatement_t with_1_statements[] = { + { OP(0, 0, 0, OP_WITH), 0, 4, 1 }, + { OP(0, 1, 0, OP_WITH), 1, 2, 2 }, + { OP(0, 1, 0, OP_WITH), 1, -2, 3 }, + { OP(0, 0, 0, OP_WITH), 8, 0, 0 }, // pushregs + { OP(0, 0, 0, OP_POP_A_4), 4, 0, 0 }, +}; + +static pr_ivec4_t with_2_init[] = { + { 4, 5, 6, 7}, + { DB, DB, DB, DB}, + { DB, DB, DB, DB}, + { DB, DB, DB, DB}, +}; + +static pr_ivec4_t with_2_expect[] = { + { 4, 5, 6, 7}, + { 0, 44, 48, 40}, + { DB, DB, DB, DB}, + { DB, DB, DB, DB}, +}; + +static dstatement_t with_2_statements[] = { + { OP(0, 0, 0, OP_PUSH_A_4), 0, 0, 0 }, // so something is on the stack + { OP(0, 0, 0, OP_WITH), 2, 0, 1 }, + { OP(0, 1, 0, OP_WITH), 2, 4, 2 }, + { OP(0, 1, 0, OP_WITH), 2, -4, 3 }, + { OP(0, 0, 0, OP_WITH), 8, 0, 0 }, // pushregs + { OP(0, 0, 0, OP_POP_A_4), 4, 0, 0 }, +}; + +static pr_ivec4_t with_3_init[] = { + { 4, 5, 6, 7}, + { DB, DB, DB, DB}, +}; + +static pr_ivec4_t with_3_expect[] = { + { 4, 5, 6, 7}, + { 0, 64, 68, 65596}, // edict-area relative is only +ve +}; + +static dstatement_t with_3_statements[] = { + { OP(0, 0, 0, OP_WITH), 3, 0, 1 }, + { OP(0, 1, 0, OP_WITH), 3, 4, 2 }, + { OP(0, 1, 0, OP_WITH), 3, -4, 3 }, + { OP(0, 0, 0, OP_WITH), 8, 0, 0 }, // pushregs + { OP(0, 0, 0, OP_POP_A_4), 4, 0, 0 }, +}; + +static pr_ivec4_t with_4_init[] = { + { 4, 5, 6, 7}, + { DB, DB, DB, DB}, +}; + +static pr_ivec4_t with_4_expect[] = { + { 4, 5, 6, 7}, + { 0, 4, 5, 6}, +}; + +static dstatement_t with_4_statements[] = { + { OP(0, 0, 0, OP_WITH), 4, 0, 1 }, + { OP(0, 1, 0, OP_WITH), 4, 1, 2 }, + { OP(0, 1, 0, OP_WITH), 4, 2, 3 }, + { OP(0, 0, 0, OP_WITH), 8, 0, 0 }, // pushregs + { OP(0, 0, 0, OP_POP_A_4), 4, 0, 0 }, +}; + +static pr_ivec4_t with_5_init[] = { + { 4, 5, 6, 7}, + { DB, DB, DB, DB}, +}; + +static pr_ivec4_t with_5_expect[] = { + { 4, 5, 6, 7}, + { 0, 2, 6, 7}, +}; + +static dstatement_t with_5_statements[] = { + { OP(0, 0, 0, OP_WITH), 0, 2, 1 }, + { OP(0, 1, 0, OP_WITH), 5, 0, 2 }, + { OP(0, 1, 0, OP_WITH), 5, 1, 3 }, + { OP(0, 0, 0, OP_WITH), 8, 0, 0 }, // pushregs + { OP(0, 0, 0, OP_POP_A_4), 4, 0, 0 }, +}; + +static pr_ivec4_t with_6_init[] = { + { 4, 5, 6, -4}, + { DB, DB, DB, DB}, + { DB, DB, DB, DB}, + { DB, DB, DB, DB}, +}; + +static pr_ivec4_t with_6_expect[] = { + { 4, 5, 6, -4}, + { 0, 44, 48, 40}, + { DB, DB, DB, DB}, + { DB, DB, DB, DB}, +}; + +static dstatement_t with_6_statements[] = { + { OP(0, 0, 0, OP_PUSH_A_4), 0, 0, 0 }, // so something is on the stack + { OP(0, 0, 0, OP_WITH), 2, 0, 1 }, + { OP(0, 1, 0, OP_WITH), 6, 0, 2 }, + { OP(0, 1, 0, OP_WITH), 6, 3, 3 }, + { OP(0, 0, 0, OP_WITH), 8, 0, 0 }, // pushregs + { OP(0, 0, 0, OP_POP_A_4), 4, 0, 0 }, +}; + +static pr_ivec4_t with_7_init[] = { + { 4, 5, 6, -4}, + { DB, DB, DB, DB}, +}; + +static pr_ivec4_t with_7_expect[] = { + { 4, 5, 6, -4}, + { 0, 2, 70, 60}, // edict-area relative is only +ve, but 32-bit wrap +}; + +static dstatement_t with_7_statements[] = { + { OP(0, 0, 0, OP_WITH), 0, 2, 1 }, + { OP(0, 1, 0, OP_WITH), 7, 0, 2 }, + { OP(0, 1, 0, OP_WITH), 7, 1, 3 }, + { OP(0, 0, 0, OP_WITH), 8, 0, 0 }, // pushregs + { OP(0, 0, 0, OP_POP_A_4), 4, 0, 0 }, +}; + +test_t tests[] = { + { + .desc = "pushregs", + .num_globals = num_globals(pushregs_init,pushregs_expect), + .num_statements = num_statements (pushregs_statements), + .statements = pushregs_statements, + .init_globals = (pr_int_t *) pushregs_init, + .expect_globals = (pr_int_t *) pushregs_expect, + .stack_size = 32, + }, + { + .desc = "popregs", + .num_globals = num_globals(popregs_init,popregs_expect), + .num_statements = num_statements (popregs_statements), + .statements = popregs_statements, + .init_globals = (pr_int_t *) popregs_init, + .expect_globals = (pr_int_t *) popregs_expect, + .stack_size = 32, + }, + { + .desc = "with 0", + .num_globals = num_globals(with_0_init,with_0_expect), + .num_statements = num_statements (with_0_statements), + .statements = with_0_statements, + .init_globals = (pr_int_t *) with_0_init, + .expect_globals = (pr_int_t *) with_0_expect, + .stack_size = 32, + }, + { + .desc = "with 1", + .num_globals = num_globals(with_1_init,with_1_expect), + .num_statements = num_statements (with_1_statements), + .statements = with_1_statements, + .init_globals = (pr_int_t *) with_1_init, + .expect_globals = (pr_int_t *) with_1_expect, + .stack_size = 32, + .edict_area = 64, + }, + { + .desc = "with 2", + .num_globals = num_globals(with_2_init,with_2_expect), + .num_statements = num_statements (with_2_statements), + .statements = with_2_statements, + .init_globals = (pr_int_t *) with_2_init, + .expect_globals = (pr_int_t *) with_2_expect, + .stack_size = 32, + .edict_area = 64, + }, + { + .desc = "with 3", + .num_globals = num_globals(with_3_init,with_3_expect), + .num_statements = num_statements (with_3_statements), + .statements = with_3_statements, + .init_globals = (pr_int_t *) with_3_init, + .expect_globals = (pr_int_t *) with_3_expect, + .stack_size = 32, + .edict_area = 64, + }, + { + .desc = "with 4", + .num_globals = num_globals(with_4_init,with_4_expect), + .num_statements = num_statements (with_4_statements), + .statements = with_4_statements, + .init_globals = (pr_int_t *) with_4_init, + .expect_globals = (pr_int_t *) with_4_expect, + .stack_size = 32, + .edict_area = 64, + }, + { + .desc = "with 5", + .num_globals = num_globals(with_5_init,with_5_expect), + .num_statements = num_statements (with_5_statements), + .statements = with_5_statements, + .init_globals = (pr_int_t *) with_5_init, + .expect_globals = (pr_int_t *) with_5_expect, + .stack_size = 32, + .edict_area = 64, + }, + { + .desc = "with 6", + .num_globals = num_globals(with_6_init,with_6_expect), + .num_statements = num_statements (with_6_statements), + .statements = with_6_statements, + .init_globals = (pr_int_t *) with_6_init, + .expect_globals = (pr_int_t *) with_6_expect, + .stack_size = 32, + .edict_area = 64, + }, + { + .desc = "with 7", + .num_globals = num_globals(with_7_init,with_7_expect), + .num_statements = num_statements (with_7_statements), + .statements = with_7_statements, + .init_globals = (pr_int_t *) with_7_init, + .expect_globals = (pr_int_t *) with_7_expect, + .stack_size = 32, + .edict_area = 64, + }, +}; + +#include "main.c" From dc4df49fff85a6dd2b096abecbc8816d34c447bf Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 15 Jan 2022 22:44:58 +0900 Subject: [PATCH 113/360] [gamecode] Add tests for the swizzle instructions While not always generated (yet?) the tests are at least in. Just not sure about auto-generated tests that can't be hand-edited. --- libs/gamecode/swizzle.py | 170 ++- libs/gamecode/test/Makemodule.am | 6 + libs/gamecode/test/test-swizzle.c | 1846 +++++++++++++++++++++++++++++ 3 files changed, 2018 insertions(+), 4 deletions(-) create mode 100644 libs/gamecode/test/test-swizzle.c diff --git a/libs/gamecode/swizzle.py b/libs/gamecode/swizzle.py index 673f5aec4..f61d50de5 100644 --- a/libs/gamecode/swizzle.py +++ b/libs/gamecode/swizzle.py @@ -5,6 +5,12 @@ def iter(func): for l in range(4): func(i, j, k, l) +def iter16(func): + for i in range(16): + func(i) + +import sys + coord=['x', 'y', 'z', 'w'] def label(i, j, k, l): return f"swizzle_{coord[l]}{coord[k]}{coord[j]}{coord[i]}" @@ -15,7 +21,163 @@ def print_ref(i, j, k, l): def print_op(i, j, k, l): print(f"\t{label(i, j, k, l)}: vec = swizzle (vec, (pr_ivec4_t) {{ {l}, {k}, {j}, {i} }}); goto negate;") -iter(print_op) -print("\tstatic void *swizzle_table[256] = {") -iter(print_ref) -print("\t};") +def print_data(i, j, k, l): + print(f"\t{{ {l+1:2}, {k+1:2}, {j+1:2}, {i+1:2} }},") + +def print_swizzle_f(i, j, k, l): + swiz = i * 64 + j * 16 + k * 4 + l + addr = (swiz + 1) * 4 + print(f"\t{{ OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x{swiz:04x}, {addr} }},") + +def print_neg_f(i): + swiz = i * 0x100 + 0xe4 + addr = (i + 1) * 4 + print(f"\t{{ OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x{swiz:04x}, {addr} }},") + +def print_zero_f(i): + swiz = i * 0x1000 + 0xe4 + addr = (i + 1) * 4 + print(f"\t{{ OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x{swiz:04x}, {addr} }},") + +def print_swizzle_d(i, j, k, l): + swiz = i * 64 + j * 16 + k * 4 + l + addr = (swiz + 1) * 8 + print(f"\t{{ OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x{swiz:04x}, {addr} }},") + +def print_neg_d(i): + swiz = i * 0x100 + 0xe4 + addr = (i + 1) * 8 + print(f"\t{{ OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x{swiz:04x}, {addr} }},") + +def print_zero_d(i): + swiz = i * 0x1000 + 0xe4 + addr = (i + 1) * 8 + print(f"\t{{ OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x{swiz:04x}, {addr} }},") + +def print_eights(i, j, k, l): + print(f"\t{{ {8:2}, {8:2}, {8:2}, {8:2} }},") + +def print_nines(i): + print(f"\t{{ {9:2}, {9:2}, {9:2}, {9:2} }},") + +def print_neg(n): + x = [1, 2, 3, 4] + for i in range(4): + if n & (1<< i): + x[i] = -x[i] + print(f"\t{{ {x[0]:2}, {x[1]:2}, {x[2]:2}, {x[3]:2} }},") + +def print_zero(z): + x = [1, 2, 3, 4] + for i in range(4): + if z & (1<< i): + x[i] = 0 + print(f"\t{{ {x[0]:2}, {x[1]:2}, {x[2]:2}, {x[3]:2} }},") + +types = ["f", "d"] +tests = ["swizzle", "neg", "zero"] + +if sys.argv[1] == "case": + iter(print_op) + print("\tstatic void *swizzle_table[256] = {") + iter(print_ref) + print("\t};") +elif sys.argv[1] == "test": + print('#include "head.c"') + print() + print("static pr_vec4_t swizzle_f_init[] = {") + print_data(3, 2, 1, 0) + iter(print_eights) + print("};") + print("static pr_vec4_t swizzle_f_expect[] = {") + print_data(3, 2, 1, 0) + iter(print_data) + print("};") + print() + print("static dstatement_t swizzle_f_statements[] = {") + iter(print_swizzle_f) + print("};") + print() + print("static pr_vec4_t neg_f_init[] = {") + print_neg(0) + iter16(print_nines) + print("};") + print() + print("static pr_vec4_t neg_f_expect[] = {") + print_neg(0) + iter16(print_neg) + print("};") + print() + print("static dstatement_t neg_f_statements[] = {") + iter16(print_neg_f) + print("};") + print() + print("static pr_vec4_t zero_f_init[] = {") + print_zero(0) + iter16(print_nines) + print("};") + print() + print("static pr_vec4_t zero_f_expect[] = {") + print_zero(0) + iter16(print_zero) + print("};") + print() + print("static dstatement_t zero_f_statements[] = {") + iter16(print_zero_f) + print("};") + print() + print("static pr_dvec4_t swizzle_d_init[] = {") + print_data(3, 2, 1, 0) + iter(print_eights) + print("};") + print("static pr_dvec4_t swizzle_d_expect[] = {") + print_data(3, 2, 1, 0) + iter(print_data) + print("};") + print() + print("static dstatement_t swizzle_d_statements[] = {") + iter(print_swizzle_d) + print("};") + print() + print("static pr_dvec4_t neg_d_init[] = {") + print_neg(0) + iter16(print_nines) + print("};") + print() + print("static pr_dvec4_t neg_d_expect[] = {") + print_neg(0) + iter16(print_neg) + print("};") + print() + print("static dstatement_t neg_d_statements[] = {") + iter16(print_neg_d) + print("};") + print() + print("static pr_dvec4_t zero_d_init[] = {") + print_zero(0) + iter16(print_nines) + print("};") + print() + print("static pr_dvec4_t zero_d_expect[] = {") + print_zero(0) + iter16(print_zero) + print("};") + print() + print("static dstatement_t zero_d_statements[] = {") + iter16(print_zero_d) + print("};") + print() + print("test_t tests[] = {") + for t in types: + for o in tests: + print("\t{") + print(f'\t\t.desc = "{o} {t}",') + print(f"\t\t.num_globals = num_globals({o}_{t}_init,{o}_{t}_expect),") + print(f"\t\t.num_statements = num_statements({o}_{t}_statements),") + print(f"\t\t.statements = {o}_{t}_statements,") + print(f"\t\t.init_globals = (pr_int_t *) {o}_{t}_init,") + print(f"\t\t.expect_globals = (pr_int_t *) {o}_{t}_expect,") + print("\t},") + print("};") + print() + print('#include "main.c"') diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index 8fc813622..0788861f8 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -19,6 +19,7 @@ libs_gamecode_tests = \ libs/gamecode/test/test-stack \ libs/gamecode/test/test-store \ libs/gamecode/test/test-string \ + libs/gamecode/test/test-swizzle \ libs/gamecode/test/test-unsigned \ libs/gamecode/test/test-vector \ libs/gamecode/test/test-with @@ -133,6 +134,11 @@ libs_gamecode_test_test_string_SOURCES= \ libs_gamecode_test_test_string_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_string_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_swizzle_SOURCES= \ + libs/gamecode/test/test-swizzle.c +libs_gamecode_test_test_swizzle_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_swizzle_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_unsigned_SOURCES= \ libs/gamecode/test/test-unsigned.c libs_gamecode_test_test_unsigned_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-swizzle.c b/libs/gamecode/test/test-swizzle.c new file mode 100644 index 000000000..c47acbb5c --- /dev/null +++ b/libs/gamecode/test/test-swizzle.c @@ -0,0 +1,1846 @@ +#include "head.c" + +static pr_vec4_t swizzle_f_init[] = { + { 1, 2, 3, 4 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, +}; +static pr_vec4_t swizzle_f_expect[] = { + { 1, 2, 3, 4 }, + { 1, 1, 1, 1 }, + { 2, 1, 1, 1 }, + { 3, 1, 1, 1 }, + { 4, 1, 1, 1 }, + { 1, 2, 1, 1 }, + { 2, 2, 1, 1 }, + { 3, 2, 1, 1 }, + { 4, 2, 1, 1 }, + { 1, 3, 1, 1 }, + { 2, 3, 1, 1 }, + { 3, 3, 1, 1 }, + { 4, 3, 1, 1 }, + { 1, 4, 1, 1 }, + { 2, 4, 1, 1 }, + { 3, 4, 1, 1 }, + { 4, 4, 1, 1 }, + { 1, 1, 2, 1 }, + { 2, 1, 2, 1 }, + { 3, 1, 2, 1 }, + { 4, 1, 2, 1 }, + { 1, 2, 2, 1 }, + { 2, 2, 2, 1 }, + { 3, 2, 2, 1 }, + { 4, 2, 2, 1 }, + { 1, 3, 2, 1 }, + { 2, 3, 2, 1 }, + { 3, 3, 2, 1 }, + { 4, 3, 2, 1 }, + { 1, 4, 2, 1 }, + { 2, 4, 2, 1 }, + { 3, 4, 2, 1 }, + { 4, 4, 2, 1 }, + { 1, 1, 3, 1 }, + { 2, 1, 3, 1 }, + { 3, 1, 3, 1 }, + { 4, 1, 3, 1 }, + { 1, 2, 3, 1 }, + { 2, 2, 3, 1 }, + { 3, 2, 3, 1 }, + { 4, 2, 3, 1 }, + { 1, 3, 3, 1 }, + { 2, 3, 3, 1 }, + { 3, 3, 3, 1 }, + { 4, 3, 3, 1 }, + { 1, 4, 3, 1 }, + { 2, 4, 3, 1 }, + { 3, 4, 3, 1 }, + { 4, 4, 3, 1 }, + { 1, 1, 4, 1 }, + { 2, 1, 4, 1 }, + { 3, 1, 4, 1 }, + { 4, 1, 4, 1 }, + { 1, 2, 4, 1 }, + { 2, 2, 4, 1 }, + { 3, 2, 4, 1 }, + { 4, 2, 4, 1 }, + { 1, 3, 4, 1 }, + { 2, 3, 4, 1 }, + { 3, 3, 4, 1 }, + { 4, 3, 4, 1 }, + { 1, 4, 4, 1 }, + { 2, 4, 4, 1 }, + { 3, 4, 4, 1 }, + { 4, 4, 4, 1 }, + { 1, 1, 1, 2 }, + { 2, 1, 1, 2 }, + { 3, 1, 1, 2 }, + { 4, 1, 1, 2 }, + { 1, 2, 1, 2 }, + { 2, 2, 1, 2 }, + { 3, 2, 1, 2 }, + { 4, 2, 1, 2 }, + { 1, 3, 1, 2 }, + { 2, 3, 1, 2 }, + { 3, 3, 1, 2 }, + { 4, 3, 1, 2 }, + { 1, 4, 1, 2 }, + { 2, 4, 1, 2 }, + { 3, 4, 1, 2 }, + { 4, 4, 1, 2 }, + { 1, 1, 2, 2 }, + { 2, 1, 2, 2 }, + { 3, 1, 2, 2 }, + { 4, 1, 2, 2 }, + { 1, 2, 2, 2 }, + { 2, 2, 2, 2 }, + { 3, 2, 2, 2 }, + { 4, 2, 2, 2 }, + { 1, 3, 2, 2 }, + { 2, 3, 2, 2 }, + { 3, 3, 2, 2 }, + { 4, 3, 2, 2 }, + { 1, 4, 2, 2 }, + { 2, 4, 2, 2 }, + { 3, 4, 2, 2 }, + { 4, 4, 2, 2 }, + { 1, 1, 3, 2 }, + { 2, 1, 3, 2 }, + { 3, 1, 3, 2 }, + { 4, 1, 3, 2 }, + { 1, 2, 3, 2 }, + { 2, 2, 3, 2 }, + { 3, 2, 3, 2 }, + { 4, 2, 3, 2 }, + { 1, 3, 3, 2 }, + { 2, 3, 3, 2 }, + { 3, 3, 3, 2 }, + { 4, 3, 3, 2 }, + { 1, 4, 3, 2 }, + { 2, 4, 3, 2 }, + { 3, 4, 3, 2 }, + { 4, 4, 3, 2 }, + { 1, 1, 4, 2 }, + { 2, 1, 4, 2 }, + { 3, 1, 4, 2 }, + { 4, 1, 4, 2 }, + { 1, 2, 4, 2 }, + { 2, 2, 4, 2 }, + { 3, 2, 4, 2 }, + { 4, 2, 4, 2 }, + { 1, 3, 4, 2 }, + { 2, 3, 4, 2 }, + { 3, 3, 4, 2 }, + { 4, 3, 4, 2 }, + { 1, 4, 4, 2 }, + { 2, 4, 4, 2 }, + { 3, 4, 4, 2 }, + { 4, 4, 4, 2 }, + { 1, 1, 1, 3 }, + { 2, 1, 1, 3 }, + { 3, 1, 1, 3 }, + { 4, 1, 1, 3 }, + { 1, 2, 1, 3 }, + { 2, 2, 1, 3 }, + { 3, 2, 1, 3 }, + { 4, 2, 1, 3 }, + { 1, 3, 1, 3 }, + { 2, 3, 1, 3 }, + { 3, 3, 1, 3 }, + { 4, 3, 1, 3 }, + { 1, 4, 1, 3 }, + { 2, 4, 1, 3 }, + { 3, 4, 1, 3 }, + { 4, 4, 1, 3 }, + { 1, 1, 2, 3 }, + { 2, 1, 2, 3 }, + { 3, 1, 2, 3 }, + { 4, 1, 2, 3 }, + { 1, 2, 2, 3 }, + { 2, 2, 2, 3 }, + { 3, 2, 2, 3 }, + { 4, 2, 2, 3 }, + { 1, 3, 2, 3 }, + { 2, 3, 2, 3 }, + { 3, 3, 2, 3 }, + { 4, 3, 2, 3 }, + { 1, 4, 2, 3 }, + { 2, 4, 2, 3 }, + { 3, 4, 2, 3 }, + { 4, 4, 2, 3 }, + { 1, 1, 3, 3 }, + { 2, 1, 3, 3 }, + { 3, 1, 3, 3 }, + { 4, 1, 3, 3 }, + { 1, 2, 3, 3 }, + { 2, 2, 3, 3 }, + { 3, 2, 3, 3 }, + { 4, 2, 3, 3 }, + { 1, 3, 3, 3 }, + { 2, 3, 3, 3 }, + { 3, 3, 3, 3 }, + { 4, 3, 3, 3 }, + { 1, 4, 3, 3 }, + { 2, 4, 3, 3 }, + { 3, 4, 3, 3 }, + { 4, 4, 3, 3 }, + { 1, 1, 4, 3 }, + { 2, 1, 4, 3 }, + { 3, 1, 4, 3 }, + { 4, 1, 4, 3 }, + { 1, 2, 4, 3 }, + { 2, 2, 4, 3 }, + { 3, 2, 4, 3 }, + { 4, 2, 4, 3 }, + { 1, 3, 4, 3 }, + { 2, 3, 4, 3 }, + { 3, 3, 4, 3 }, + { 4, 3, 4, 3 }, + { 1, 4, 4, 3 }, + { 2, 4, 4, 3 }, + { 3, 4, 4, 3 }, + { 4, 4, 4, 3 }, + { 1, 1, 1, 4 }, + { 2, 1, 1, 4 }, + { 3, 1, 1, 4 }, + { 4, 1, 1, 4 }, + { 1, 2, 1, 4 }, + { 2, 2, 1, 4 }, + { 3, 2, 1, 4 }, + { 4, 2, 1, 4 }, + { 1, 3, 1, 4 }, + { 2, 3, 1, 4 }, + { 3, 3, 1, 4 }, + { 4, 3, 1, 4 }, + { 1, 4, 1, 4 }, + { 2, 4, 1, 4 }, + { 3, 4, 1, 4 }, + { 4, 4, 1, 4 }, + { 1, 1, 2, 4 }, + { 2, 1, 2, 4 }, + { 3, 1, 2, 4 }, + { 4, 1, 2, 4 }, + { 1, 2, 2, 4 }, + { 2, 2, 2, 4 }, + { 3, 2, 2, 4 }, + { 4, 2, 2, 4 }, + { 1, 3, 2, 4 }, + { 2, 3, 2, 4 }, + { 3, 3, 2, 4 }, + { 4, 3, 2, 4 }, + { 1, 4, 2, 4 }, + { 2, 4, 2, 4 }, + { 3, 4, 2, 4 }, + { 4, 4, 2, 4 }, + { 1, 1, 3, 4 }, + { 2, 1, 3, 4 }, + { 3, 1, 3, 4 }, + { 4, 1, 3, 4 }, + { 1, 2, 3, 4 }, + { 2, 2, 3, 4 }, + { 3, 2, 3, 4 }, + { 4, 2, 3, 4 }, + { 1, 3, 3, 4 }, + { 2, 3, 3, 4 }, + { 3, 3, 3, 4 }, + { 4, 3, 3, 4 }, + { 1, 4, 3, 4 }, + { 2, 4, 3, 4 }, + { 3, 4, 3, 4 }, + { 4, 4, 3, 4 }, + { 1, 1, 4, 4 }, + { 2, 1, 4, 4 }, + { 3, 1, 4, 4 }, + { 4, 1, 4, 4 }, + { 1, 2, 4, 4 }, + { 2, 2, 4, 4 }, + { 3, 2, 4, 4 }, + { 4, 2, 4, 4 }, + { 1, 3, 4, 4 }, + { 2, 3, 4, 4 }, + { 3, 3, 4, 4 }, + { 4, 3, 4, 4 }, + { 1, 4, 4, 4 }, + { 2, 4, 4, 4 }, + { 3, 4, 4, 4 }, + { 4, 4, 4, 4 }, +}; + +static dstatement_t swizzle_f_statements[] = { + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0000, 4 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0001, 8 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0002, 12 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0003, 16 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0004, 20 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0005, 24 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0006, 28 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0007, 32 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0008, 36 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0009, 40 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x000a, 44 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x000b, 48 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x000c, 52 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x000d, 56 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x000e, 60 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x000f, 64 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0010, 68 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0011, 72 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0012, 76 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0013, 80 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0014, 84 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0015, 88 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0016, 92 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0017, 96 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0018, 100 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0019, 104 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x001a, 108 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x001b, 112 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x001c, 116 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x001d, 120 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x001e, 124 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x001f, 128 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0020, 132 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0021, 136 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0022, 140 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0023, 144 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0024, 148 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0025, 152 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0026, 156 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0027, 160 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0028, 164 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0029, 168 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x002a, 172 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x002b, 176 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x002c, 180 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x002d, 184 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x002e, 188 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x002f, 192 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0030, 196 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0031, 200 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0032, 204 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0033, 208 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0034, 212 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0035, 216 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0036, 220 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0037, 224 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0038, 228 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0039, 232 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x003a, 236 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x003b, 240 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x003c, 244 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x003d, 248 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x003e, 252 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x003f, 256 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0040, 260 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0041, 264 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0042, 268 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0043, 272 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0044, 276 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0045, 280 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0046, 284 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0047, 288 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0048, 292 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0049, 296 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x004a, 300 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x004b, 304 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x004c, 308 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x004d, 312 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x004e, 316 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x004f, 320 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0050, 324 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0051, 328 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0052, 332 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0053, 336 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0054, 340 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0055, 344 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0056, 348 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0057, 352 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0058, 356 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0059, 360 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x005a, 364 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x005b, 368 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x005c, 372 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x005d, 376 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x005e, 380 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x005f, 384 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0060, 388 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0061, 392 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0062, 396 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0063, 400 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0064, 404 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0065, 408 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0066, 412 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0067, 416 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0068, 420 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0069, 424 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x006a, 428 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x006b, 432 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x006c, 436 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x006d, 440 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x006e, 444 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x006f, 448 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0070, 452 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0071, 456 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0072, 460 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0073, 464 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0074, 468 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0075, 472 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0076, 476 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0077, 480 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0078, 484 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0079, 488 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x007a, 492 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x007b, 496 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x007c, 500 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x007d, 504 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x007e, 508 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x007f, 512 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0080, 516 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0081, 520 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0082, 524 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0083, 528 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0084, 532 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0085, 536 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0086, 540 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0087, 544 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0088, 548 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0089, 552 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x008a, 556 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x008b, 560 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x008c, 564 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x008d, 568 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x008e, 572 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x008f, 576 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0090, 580 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0091, 584 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0092, 588 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0093, 592 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0094, 596 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0095, 600 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0096, 604 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0097, 608 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0098, 612 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0099, 616 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x009a, 620 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x009b, 624 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x009c, 628 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x009d, 632 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x009e, 636 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x009f, 640 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00a0, 644 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00a1, 648 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00a2, 652 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00a3, 656 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00a4, 660 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00a5, 664 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00a6, 668 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00a7, 672 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00a8, 676 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00a9, 680 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00aa, 684 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00ab, 688 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00ac, 692 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00ad, 696 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00ae, 700 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00af, 704 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00b0, 708 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00b1, 712 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00b2, 716 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00b3, 720 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00b4, 724 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00b5, 728 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00b6, 732 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00b7, 736 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00b8, 740 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00b9, 744 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00ba, 748 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00bb, 752 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00bc, 756 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00bd, 760 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00be, 764 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00bf, 768 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00c0, 772 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00c1, 776 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00c2, 780 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00c3, 784 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00c4, 788 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00c5, 792 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00c6, 796 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00c7, 800 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00c8, 804 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00c9, 808 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00ca, 812 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00cb, 816 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00cc, 820 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00cd, 824 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00ce, 828 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00cf, 832 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00d0, 836 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00d1, 840 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00d2, 844 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00d3, 848 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00d4, 852 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00d5, 856 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00d6, 860 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00d7, 864 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00d8, 868 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00d9, 872 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00da, 876 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00db, 880 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00dc, 884 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00dd, 888 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00de, 892 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00df, 896 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00e0, 900 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00e1, 904 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00e2, 908 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00e3, 912 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00e4, 916 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00e5, 920 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00e6, 924 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00e7, 928 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00e8, 932 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00e9, 936 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00ea, 940 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00eb, 944 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00ec, 948 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00ed, 952 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00ee, 956 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00ef, 960 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00f0, 964 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00f1, 968 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00f2, 972 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00f3, 976 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00f4, 980 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00f5, 984 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00f6, 988 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00f7, 992 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00f8, 996 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00f9, 1000 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00fa, 1004 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00fb, 1008 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00fc, 1012 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00fd, 1016 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00fe, 1020 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00ff, 1024 }, +}; + +static pr_vec4_t neg_f_init[] = { + { 1, 2, 3, 4 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, +}; + +static pr_vec4_t neg_f_expect[] = { + { 1, 2, 3, 4 }, + { 1, 2, 3, 4 }, + { -1, 2, 3, 4 }, + { 1, -2, 3, 4 }, + { -1, -2, 3, 4 }, + { 1, 2, -3, 4 }, + { -1, 2, -3, 4 }, + { 1, -2, -3, 4 }, + { -1, -2, -3, 4 }, + { 1, 2, 3, -4 }, + { -1, 2, 3, -4 }, + { 1, -2, 3, -4 }, + { -1, -2, 3, -4 }, + { 1, 2, -3, -4 }, + { -1, 2, -3, -4 }, + { 1, -2, -3, -4 }, + { -1, -2, -3, -4 }, +}; + +static dstatement_t neg_f_statements[] = { + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00e4, 4 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x01e4, 8 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x02e4, 12 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x03e4, 16 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x04e4, 20 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x05e4, 24 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x06e4, 28 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x07e4, 32 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x08e4, 36 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x09e4, 40 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0ae4, 44 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0be4, 48 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0ce4, 52 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0de4, 56 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0ee4, 60 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x0fe4, 64 }, +}; + +static pr_vec4_t zero_f_init[] = { + { 1, 2, 3, 4 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, +}; + +static pr_vec4_t zero_f_expect[] = { + { 1, 2, 3, 4 }, + { 1, 2, 3, 4 }, + { 0, 2, 3, 4 }, + { 1, 0, 3, 4 }, + { 0, 0, 3, 4 }, + { 1, 2, 0, 4 }, + { 0, 2, 0, 4 }, + { 1, 0, 0, 4 }, + { 0, 0, 0, 4 }, + { 1, 2, 3, 0 }, + { 0, 2, 3, 0 }, + { 1, 0, 3, 0 }, + { 0, 0, 3, 0 }, + { 1, 2, 0, 0 }, + { 0, 2, 0, 0 }, + { 1, 0, 0, 0 }, + { 0, 0, 0, 0 }, +}; + +static dstatement_t zero_f_statements[] = { + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x00e4, 4 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x10e4, 8 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x20e4, 12 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x30e4, 16 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x40e4, 20 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x50e4, 24 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x60e4, 28 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x70e4, 32 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x80e4, 36 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0x90e4, 40 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0xa0e4, 44 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0xb0e4, 48 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0xc0e4, 52 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0xd0e4, 56 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0xe0e4, 60 }, + { OP(0, 0, 0, OP_SWIZZLE_F), 0, 0xf0e4, 64 }, +}; + +static pr_dvec4_t swizzle_d_init[] = { + { 1, 2, 3, 4 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, + { 8, 8, 8, 8 }, +}; +static pr_dvec4_t swizzle_d_expect[] = { + { 1, 2, 3, 4 }, + { 1, 1, 1, 1 }, + { 2, 1, 1, 1 }, + { 3, 1, 1, 1 }, + { 4, 1, 1, 1 }, + { 1, 2, 1, 1 }, + { 2, 2, 1, 1 }, + { 3, 2, 1, 1 }, + { 4, 2, 1, 1 }, + { 1, 3, 1, 1 }, + { 2, 3, 1, 1 }, + { 3, 3, 1, 1 }, + { 4, 3, 1, 1 }, + { 1, 4, 1, 1 }, + { 2, 4, 1, 1 }, + { 3, 4, 1, 1 }, + { 4, 4, 1, 1 }, + { 1, 1, 2, 1 }, + { 2, 1, 2, 1 }, + { 3, 1, 2, 1 }, + { 4, 1, 2, 1 }, + { 1, 2, 2, 1 }, + { 2, 2, 2, 1 }, + { 3, 2, 2, 1 }, + { 4, 2, 2, 1 }, + { 1, 3, 2, 1 }, + { 2, 3, 2, 1 }, + { 3, 3, 2, 1 }, + { 4, 3, 2, 1 }, + { 1, 4, 2, 1 }, + { 2, 4, 2, 1 }, + { 3, 4, 2, 1 }, + { 4, 4, 2, 1 }, + { 1, 1, 3, 1 }, + { 2, 1, 3, 1 }, + { 3, 1, 3, 1 }, + { 4, 1, 3, 1 }, + { 1, 2, 3, 1 }, + { 2, 2, 3, 1 }, + { 3, 2, 3, 1 }, + { 4, 2, 3, 1 }, + { 1, 3, 3, 1 }, + { 2, 3, 3, 1 }, + { 3, 3, 3, 1 }, + { 4, 3, 3, 1 }, + { 1, 4, 3, 1 }, + { 2, 4, 3, 1 }, + { 3, 4, 3, 1 }, + { 4, 4, 3, 1 }, + { 1, 1, 4, 1 }, + { 2, 1, 4, 1 }, + { 3, 1, 4, 1 }, + { 4, 1, 4, 1 }, + { 1, 2, 4, 1 }, + { 2, 2, 4, 1 }, + { 3, 2, 4, 1 }, + { 4, 2, 4, 1 }, + { 1, 3, 4, 1 }, + { 2, 3, 4, 1 }, + { 3, 3, 4, 1 }, + { 4, 3, 4, 1 }, + { 1, 4, 4, 1 }, + { 2, 4, 4, 1 }, + { 3, 4, 4, 1 }, + { 4, 4, 4, 1 }, + { 1, 1, 1, 2 }, + { 2, 1, 1, 2 }, + { 3, 1, 1, 2 }, + { 4, 1, 1, 2 }, + { 1, 2, 1, 2 }, + { 2, 2, 1, 2 }, + { 3, 2, 1, 2 }, + { 4, 2, 1, 2 }, + { 1, 3, 1, 2 }, + { 2, 3, 1, 2 }, + { 3, 3, 1, 2 }, + { 4, 3, 1, 2 }, + { 1, 4, 1, 2 }, + { 2, 4, 1, 2 }, + { 3, 4, 1, 2 }, + { 4, 4, 1, 2 }, + { 1, 1, 2, 2 }, + { 2, 1, 2, 2 }, + { 3, 1, 2, 2 }, + { 4, 1, 2, 2 }, + { 1, 2, 2, 2 }, + { 2, 2, 2, 2 }, + { 3, 2, 2, 2 }, + { 4, 2, 2, 2 }, + { 1, 3, 2, 2 }, + { 2, 3, 2, 2 }, + { 3, 3, 2, 2 }, + { 4, 3, 2, 2 }, + { 1, 4, 2, 2 }, + { 2, 4, 2, 2 }, + { 3, 4, 2, 2 }, + { 4, 4, 2, 2 }, + { 1, 1, 3, 2 }, + { 2, 1, 3, 2 }, + { 3, 1, 3, 2 }, + { 4, 1, 3, 2 }, + { 1, 2, 3, 2 }, + { 2, 2, 3, 2 }, + { 3, 2, 3, 2 }, + { 4, 2, 3, 2 }, + { 1, 3, 3, 2 }, + { 2, 3, 3, 2 }, + { 3, 3, 3, 2 }, + { 4, 3, 3, 2 }, + { 1, 4, 3, 2 }, + { 2, 4, 3, 2 }, + { 3, 4, 3, 2 }, + { 4, 4, 3, 2 }, + { 1, 1, 4, 2 }, + { 2, 1, 4, 2 }, + { 3, 1, 4, 2 }, + { 4, 1, 4, 2 }, + { 1, 2, 4, 2 }, + { 2, 2, 4, 2 }, + { 3, 2, 4, 2 }, + { 4, 2, 4, 2 }, + { 1, 3, 4, 2 }, + { 2, 3, 4, 2 }, + { 3, 3, 4, 2 }, + { 4, 3, 4, 2 }, + { 1, 4, 4, 2 }, + { 2, 4, 4, 2 }, + { 3, 4, 4, 2 }, + { 4, 4, 4, 2 }, + { 1, 1, 1, 3 }, + { 2, 1, 1, 3 }, + { 3, 1, 1, 3 }, + { 4, 1, 1, 3 }, + { 1, 2, 1, 3 }, + { 2, 2, 1, 3 }, + { 3, 2, 1, 3 }, + { 4, 2, 1, 3 }, + { 1, 3, 1, 3 }, + { 2, 3, 1, 3 }, + { 3, 3, 1, 3 }, + { 4, 3, 1, 3 }, + { 1, 4, 1, 3 }, + { 2, 4, 1, 3 }, + { 3, 4, 1, 3 }, + { 4, 4, 1, 3 }, + { 1, 1, 2, 3 }, + { 2, 1, 2, 3 }, + { 3, 1, 2, 3 }, + { 4, 1, 2, 3 }, + { 1, 2, 2, 3 }, + { 2, 2, 2, 3 }, + { 3, 2, 2, 3 }, + { 4, 2, 2, 3 }, + { 1, 3, 2, 3 }, + { 2, 3, 2, 3 }, + { 3, 3, 2, 3 }, + { 4, 3, 2, 3 }, + { 1, 4, 2, 3 }, + { 2, 4, 2, 3 }, + { 3, 4, 2, 3 }, + { 4, 4, 2, 3 }, + { 1, 1, 3, 3 }, + { 2, 1, 3, 3 }, + { 3, 1, 3, 3 }, + { 4, 1, 3, 3 }, + { 1, 2, 3, 3 }, + { 2, 2, 3, 3 }, + { 3, 2, 3, 3 }, + { 4, 2, 3, 3 }, + { 1, 3, 3, 3 }, + { 2, 3, 3, 3 }, + { 3, 3, 3, 3 }, + { 4, 3, 3, 3 }, + { 1, 4, 3, 3 }, + { 2, 4, 3, 3 }, + { 3, 4, 3, 3 }, + { 4, 4, 3, 3 }, + { 1, 1, 4, 3 }, + { 2, 1, 4, 3 }, + { 3, 1, 4, 3 }, + { 4, 1, 4, 3 }, + { 1, 2, 4, 3 }, + { 2, 2, 4, 3 }, + { 3, 2, 4, 3 }, + { 4, 2, 4, 3 }, + { 1, 3, 4, 3 }, + { 2, 3, 4, 3 }, + { 3, 3, 4, 3 }, + { 4, 3, 4, 3 }, + { 1, 4, 4, 3 }, + { 2, 4, 4, 3 }, + { 3, 4, 4, 3 }, + { 4, 4, 4, 3 }, + { 1, 1, 1, 4 }, + { 2, 1, 1, 4 }, + { 3, 1, 1, 4 }, + { 4, 1, 1, 4 }, + { 1, 2, 1, 4 }, + { 2, 2, 1, 4 }, + { 3, 2, 1, 4 }, + { 4, 2, 1, 4 }, + { 1, 3, 1, 4 }, + { 2, 3, 1, 4 }, + { 3, 3, 1, 4 }, + { 4, 3, 1, 4 }, + { 1, 4, 1, 4 }, + { 2, 4, 1, 4 }, + { 3, 4, 1, 4 }, + { 4, 4, 1, 4 }, + { 1, 1, 2, 4 }, + { 2, 1, 2, 4 }, + { 3, 1, 2, 4 }, + { 4, 1, 2, 4 }, + { 1, 2, 2, 4 }, + { 2, 2, 2, 4 }, + { 3, 2, 2, 4 }, + { 4, 2, 2, 4 }, + { 1, 3, 2, 4 }, + { 2, 3, 2, 4 }, + { 3, 3, 2, 4 }, + { 4, 3, 2, 4 }, + { 1, 4, 2, 4 }, + { 2, 4, 2, 4 }, + { 3, 4, 2, 4 }, + { 4, 4, 2, 4 }, + { 1, 1, 3, 4 }, + { 2, 1, 3, 4 }, + { 3, 1, 3, 4 }, + { 4, 1, 3, 4 }, + { 1, 2, 3, 4 }, + { 2, 2, 3, 4 }, + { 3, 2, 3, 4 }, + { 4, 2, 3, 4 }, + { 1, 3, 3, 4 }, + { 2, 3, 3, 4 }, + { 3, 3, 3, 4 }, + { 4, 3, 3, 4 }, + { 1, 4, 3, 4 }, + { 2, 4, 3, 4 }, + { 3, 4, 3, 4 }, + { 4, 4, 3, 4 }, + { 1, 1, 4, 4 }, + { 2, 1, 4, 4 }, + { 3, 1, 4, 4 }, + { 4, 1, 4, 4 }, + { 1, 2, 4, 4 }, + { 2, 2, 4, 4 }, + { 3, 2, 4, 4 }, + { 4, 2, 4, 4 }, + { 1, 3, 4, 4 }, + { 2, 3, 4, 4 }, + { 3, 3, 4, 4 }, + { 4, 3, 4, 4 }, + { 1, 4, 4, 4 }, + { 2, 4, 4, 4 }, + { 3, 4, 4, 4 }, + { 4, 4, 4, 4 }, +}; + +static dstatement_t swizzle_d_statements[] = { + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0000, 8 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0001, 16 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0002, 24 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0003, 32 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0004, 40 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0005, 48 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0006, 56 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0007, 64 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0008, 72 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0009, 80 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x000a, 88 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x000b, 96 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x000c, 104 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x000d, 112 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x000e, 120 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x000f, 128 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0010, 136 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0011, 144 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0012, 152 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0013, 160 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0014, 168 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0015, 176 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0016, 184 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0017, 192 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0018, 200 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0019, 208 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x001a, 216 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x001b, 224 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x001c, 232 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x001d, 240 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x001e, 248 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x001f, 256 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0020, 264 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0021, 272 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0022, 280 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0023, 288 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0024, 296 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0025, 304 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0026, 312 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0027, 320 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0028, 328 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0029, 336 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x002a, 344 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x002b, 352 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x002c, 360 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x002d, 368 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x002e, 376 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x002f, 384 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0030, 392 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0031, 400 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0032, 408 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0033, 416 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0034, 424 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0035, 432 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0036, 440 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0037, 448 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0038, 456 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0039, 464 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x003a, 472 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x003b, 480 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x003c, 488 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x003d, 496 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x003e, 504 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x003f, 512 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0040, 520 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0041, 528 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0042, 536 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0043, 544 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0044, 552 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0045, 560 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0046, 568 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0047, 576 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0048, 584 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0049, 592 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x004a, 600 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x004b, 608 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x004c, 616 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x004d, 624 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x004e, 632 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x004f, 640 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0050, 648 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0051, 656 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0052, 664 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0053, 672 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0054, 680 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0055, 688 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0056, 696 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0057, 704 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0058, 712 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0059, 720 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x005a, 728 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x005b, 736 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x005c, 744 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x005d, 752 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x005e, 760 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x005f, 768 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0060, 776 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0061, 784 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0062, 792 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0063, 800 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0064, 808 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0065, 816 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0066, 824 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0067, 832 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0068, 840 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0069, 848 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x006a, 856 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x006b, 864 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x006c, 872 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x006d, 880 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x006e, 888 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x006f, 896 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0070, 904 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0071, 912 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0072, 920 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0073, 928 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0074, 936 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0075, 944 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0076, 952 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0077, 960 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0078, 968 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0079, 976 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x007a, 984 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x007b, 992 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x007c, 1000 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x007d, 1008 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x007e, 1016 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x007f, 1024 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0080, 1032 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0081, 1040 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0082, 1048 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0083, 1056 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0084, 1064 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0085, 1072 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0086, 1080 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0087, 1088 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0088, 1096 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0089, 1104 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x008a, 1112 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x008b, 1120 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x008c, 1128 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x008d, 1136 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x008e, 1144 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x008f, 1152 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0090, 1160 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0091, 1168 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0092, 1176 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0093, 1184 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0094, 1192 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0095, 1200 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0096, 1208 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0097, 1216 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0098, 1224 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0099, 1232 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x009a, 1240 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x009b, 1248 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x009c, 1256 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x009d, 1264 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x009e, 1272 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x009f, 1280 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00a0, 1288 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00a1, 1296 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00a2, 1304 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00a3, 1312 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00a4, 1320 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00a5, 1328 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00a6, 1336 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00a7, 1344 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00a8, 1352 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00a9, 1360 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00aa, 1368 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00ab, 1376 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00ac, 1384 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00ad, 1392 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00ae, 1400 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00af, 1408 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00b0, 1416 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00b1, 1424 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00b2, 1432 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00b3, 1440 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00b4, 1448 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00b5, 1456 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00b6, 1464 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00b7, 1472 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00b8, 1480 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00b9, 1488 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00ba, 1496 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00bb, 1504 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00bc, 1512 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00bd, 1520 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00be, 1528 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00bf, 1536 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00c0, 1544 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00c1, 1552 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00c2, 1560 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00c3, 1568 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00c4, 1576 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00c5, 1584 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00c6, 1592 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00c7, 1600 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00c8, 1608 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00c9, 1616 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00ca, 1624 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00cb, 1632 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00cc, 1640 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00cd, 1648 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00ce, 1656 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00cf, 1664 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00d0, 1672 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00d1, 1680 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00d2, 1688 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00d3, 1696 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00d4, 1704 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00d5, 1712 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00d6, 1720 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00d7, 1728 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00d8, 1736 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00d9, 1744 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00da, 1752 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00db, 1760 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00dc, 1768 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00dd, 1776 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00de, 1784 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00df, 1792 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00e0, 1800 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00e1, 1808 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00e2, 1816 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00e3, 1824 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00e4, 1832 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00e5, 1840 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00e6, 1848 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00e7, 1856 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00e8, 1864 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00e9, 1872 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00ea, 1880 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00eb, 1888 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00ec, 1896 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00ed, 1904 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00ee, 1912 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00ef, 1920 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00f0, 1928 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00f1, 1936 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00f2, 1944 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00f3, 1952 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00f4, 1960 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00f5, 1968 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00f6, 1976 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00f7, 1984 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00f8, 1992 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00f9, 2000 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00fa, 2008 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00fb, 2016 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00fc, 2024 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00fd, 2032 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00fe, 2040 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00ff, 2048 }, +}; + +static pr_dvec4_t neg_d_init[] = { + { 1, 2, 3, 4 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, +}; + +static pr_dvec4_t neg_d_expect[] = { + { 1, 2, 3, 4 }, + { 1, 2, 3, 4 }, + { -1, 2, 3, 4 }, + { 1, -2, 3, 4 }, + { -1, -2, 3, 4 }, + { 1, 2, -3, 4 }, + { -1, 2, -3, 4 }, + { 1, -2, -3, 4 }, + { -1, -2, -3, 4 }, + { 1, 2, 3, -4 }, + { -1, 2, 3, -4 }, + { 1, -2, 3, -4 }, + { -1, -2, 3, -4 }, + { 1, 2, -3, -4 }, + { -1, 2, -3, -4 }, + { 1, -2, -3, -4 }, + { -1, -2, -3, -4 }, +}; + +static dstatement_t neg_d_statements[] = { + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00e4, 8 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x01e4, 16 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x02e4, 24 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x03e4, 32 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x04e4, 40 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x05e4, 48 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x06e4, 56 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x07e4, 64 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x08e4, 72 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x09e4, 80 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0ae4, 88 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0be4, 96 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0ce4, 104 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0de4, 112 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0ee4, 120 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x0fe4, 128 }, +}; + +static pr_dvec4_t zero_d_init[] = { + { 1, 2, 3, 4 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, + { 9, 9, 9, 9 }, +}; + +static pr_dvec4_t zero_d_expect[] = { + { 1, 2, 3, 4 }, + { 1, 2, 3, 4 }, + { 0, 2, 3, 4 }, + { 1, 0, 3, 4 }, + { 0, 0, 3, 4 }, + { 1, 2, 0, 4 }, + { 0, 2, 0, 4 }, + { 1, 0, 0, 4 }, + { 0, 0, 0, 4 }, + { 1, 2, 3, 0 }, + { 0, 2, 3, 0 }, + { 1, 0, 3, 0 }, + { 0, 0, 3, 0 }, + { 1, 2, 0, 0 }, + { 0, 2, 0, 0 }, + { 1, 0, 0, 0 }, + { 0, 0, 0, 0 }, +}; + +static dstatement_t zero_d_statements[] = { + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x00e4, 8 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x10e4, 16 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x20e4, 24 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x30e4, 32 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x40e4, 40 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x50e4, 48 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x60e4, 56 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x70e4, 64 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x80e4, 72 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0x90e4, 80 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0xa0e4, 88 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0xb0e4, 96 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0xc0e4, 104 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0xd0e4, 112 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0xe0e4, 120 }, + { OP(0, 0, 0, OP_SWIZZLE_D), 0, 0xf0e4, 128 }, +}; + +test_t tests[] = { + { + .desc = "swizzle f", + .num_globals = num_globals(swizzle_f_init,swizzle_f_expect), + .num_statements = num_statements(swizzle_f_statements), + .statements = swizzle_f_statements, + .init_globals = (pr_int_t *) swizzle_f_init, + .expect_globals = (pr_int_t *) swizzle_f_expect, + }, + { + .desc = "neg f", + .num_globals = num_globals(neg_f_init,neg_f_expect), + .num_statements = num_statements(neg_f_statements), + .statements = neg_f_statements, + .init_globals = (pr_int_t *) neg_f_init, + .expect_globals = (pr_int_t *) neg_f_expect, + }, + { + .desc = "zero f", + .num_globals = num_globals(zero_f_init,zero_f_expect), + .num_statements = num_statements(zero_f_statements), + .statements = zero_f_statements, + .init_globals = (pr_int_t *) zero_f_init, + .expect_globals = (pr_int_t *) zero_f_expect, + }, + { + .desc = "swizzle d", + .num_globals = num_globals(swizzle_d_init,swizzle_d_expect), + .num_statements = num_statements(swizzle_d_statements), + .statements = swizzle_d_statements, + .init_globals = (pr_int_t *) swizzle_d_init, + .expect_globals = (pr_int_t *) swizzle_d_expect, + }, + { + .desc = "neg d", + .num_globals = num_globals(neg_d_init,neg_d_expect), + .num_statements = num_statements(neg_d_statements), + .statements = neg_d_statements, + .init_globals = (pr_int_t *) neg_d_init, + .expect_globals = (pr_int_t *) neg_d_expect, + }, + { + .desc = "zero d", + .num_globals = num_globals(zero_d_init,zero_d_expect), + .num_statements = num_statements(zero_d_statements), + .statements = zero_d_statements, + .init_globals = (pr_int_t *) zero_d_init, + .expect_globals = (pr_int_t *) zero_d_expect, + }, +}; + +#include "main.c" From 8050c7bd77e80fdcbef18f4e97f3771eb1dbcf86 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 16 Jan 2022 14:22:04 +0900 Subject: [PATCH 114/360] [gamecode] Rearrange several instructions ANY/ALL/NONE have been temporarily removed until I implement the HOPS (horizontal operations) sub-instructions, which will all both 32-bit and 64-bit operands and several other operations (eg, horizontal add). All the fancy addressing modes for the conditional branch instructions have been permanently removed: I decided the gain was too little for the cost (24 instructions vs 6). JUMP and CALL retain their addressing modes, though. Other instructions have been shuffled around a little to fill most of the holes in the upper block of 256 instructions: just a single small 7-instruction hole. Rearrangements in the actual engine are mostly just to keep the code organized. The only real changes were the various IF statements and dealing with the resulting changes in their addressing. --- libs/gamecode/opcodes.py | 101 +++--- libs/gamecode/pr_exec.c | 477 +++++++++++++---------------- libs/gamecode/test/test-bitops.c | 8 +- libs/gamecode/test/test-conv0.c | 4 +- libs/gamecode/test/test-conv1.c | 4 +- libs/gamecode/test/test-conv2.c | 4 +- libs/gamecode/test/test-conv3.c | 4 +- libs/gamecode/test/test-conv4.c | 4 +- libs/gamecode/test/test-conv5.c | 4 +- libs/gamecode/test/test-conv6.c | 4 +- libs/gamecode/test/test-conv7.c | 4 +- libs/gamecode/test/test-double.c | 10 +- libs/gamecode/test/test-float.c | 10 +- libs/gamecode/test/test-int.c | 8 +- libs/gamecode/test/test-long.c | 8 +- libs/gamecode/test/test-string.c | 4 +- libs/gamecode/test/test-unsigned.c | 16 +- 17 files changed, 316 insertions(+), 358 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index ceccba4a7..db39a5621 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -3,41 +3,31 @@ bitmap_txt = """ 0 0001 mmss store 0 0010 mmss push 0 0011 mmss pop -0 010c ccmm branch - -# while call and return are part of the branch block, they have different -# handling for addressing and formatting -0 0101 11mm call (return specified st->c) -0 0101 1100 return (size in st->c) - -0 0110 0nnn -0 0110 10mm lea -0 0110 1100 convert (conversion mode in st->b) -0 0110 1101 with (mode in st->a, value in st->b, reg in st->c) -0 0110 111t state -0 0111 tooo vecops 0 1ccc ttss compare +0 1011 nnnn +0 1111 nnnn + 1 0ooo ttss mathops 1 011r tuss shiftops 1 0110 o1oo string 1 1ccc t0ss compare2 -1 1001 t1ss scale -1 1001 t100 swizzle -1 1010 d1xx -1 1011 00nn -1 1011 01ss any -1 1011 0100 -1 1011 10ss all -1 1011 1000 -1 1011 11ss none -1 1011 1100 -1 1101 01oo move -1 1101 11oo memset -1 1110 d1xx -1 11dd t100 vecops2 1 1t00 ooss bitops -n 1111 nnnn -0 1011 nnnn +1 1001 01mm jump +1 1001 11mm call (return specified st->c) +1 1001 1100 return (size in st->c) +1 1010 t1ss scale +1 1010 t100 swizzle +1 1011 tooo vecops +1 1101 01oo move +1 1101 0111 convert (conversion mode in st->b) +1 1101 11oo memset +1 1101 1111 with (mode in st->a, value in st->b, reg in st->c) +1 1110 c1cc branch +1 1110 t111 state +1 1111 00mm lea +1 1111 01td vecops2 +1 1111 1nnn +1 1111 1111 hops """ import copy @@ -96,16 +86,16 @@ bitops_formats = { }, } branch_formats = { - "opcode": "OP_{op_cond[ccc].upper()}_{op_mode[mm]}", - "mnemonic": "{op_cond[ccc]}", - "opname": "{op_cond[ccc]}", - "format": "{cond_fmt[ccc]}{branch_fmt[mm]}", - "widths": "{cond_widths[ccc]}", + "opcode": "OP_{op_cond[c*4+cc].upper()}", + "mnemonic": "{op_cond[c*4+cc]}", + "opname": "{op_cond[c*4+cc]}", + "format": "{cond_fmt[c*4+cc]}{branch_fmt[0]}", + "widths": "{cond_widths[c*4+cc]}", "types": "ev_void, ev_void, ev_integer", "args": { "op_mode": "ABCD", - "op_cond": ["ifz", "ifb", "ifa", "jump", - "ifnz", "ifae", "ifbe", None], #call and return seprate + "op_cond": ["ifz", "ifb", "ifa", None, + "ifnz", "ifae", "ifbe", None], "branch_fmt": branch_fmt, "cond_fmt": ["%Gc ", "%Gc ", "%Gc ", "", "%Gc ", "%Gc ", "%Gc ", ""], "cond_widths": [ @@ -169,6 +159,26 @@ convert_formats = { "widths": "1, 0, 1", "types": "ev_void, ev_short, ev_void", } +hops_formats = { + "opcode": "OP_HOPS", + "mnemonic": "hops", + "opname": "hops", + "format": "%Ga %Hb %gc", + "widths": "1, 0, 1", + "types": "ev_void, ev_short, ev_void", +} +jump_formats = { + "opcode": "OP_JUMP_{op_mode[mm]}", + "mnemonic": "jump", + "opname": "jump", + "format": "{branch_fmt[mm]}", + "widths": "0, 0, 0", + "types": "ev_void, ev_void, ev_invalid", + "args": { + "op_mode": "ABCD", + "branch_fmt": branch_fmt, + }, +} lea_formats = { "opcode": "OP_LEA_{op_mode[mm]}", "mnemonic": "lea", @@ -218,8 +228,8 @@ memset_formats = { "widths": "0, 0, 0", "types": "ev_integer, ev_void, ev_void", "args": { - "op_memset": [None, "i", "p", "pi"], - "memset_fmt": [None, "%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc"], + "op_memset": ["i", "p", "pi", None], + "memset_fmt": ["%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc", None], }, } move_formats = { @@ -230,8 +240,8 @@ move_formats = { "widths": "0, 0, 0", "types": "ev_integer, ev_void, ev_void", "args": { - "op_move": [None, "i", "p", "pi"], - "move_fmt": [None, "%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc"], + "op_move": ["i", "p", "pi", None], + "move_fmt": ["%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc", None], }, } none_formats = { @@ -423,13 +433,13 @@ vecops_formats = { }, } vecops2_formats = { - "opcode": "OP_{op_vop[dd].upper()}_{vop_type[t]}", - "mnemonic": "{op_vop[dd]}.{vop_type[t]}", - "opname": "{op_vop[dd]}", + "opcode": "OP_{op_vop[d].upper()}_{vop_type[t]}", + "mnemonic": "{op_vop[d]}.{vop_type[t]}", + "opname": "{op_vop[d]}", "widths": "4, 4, 4", "types": "{vec_types[t]}, {vec_types[t]}, {vec_types[t]}", "args": { - "op_vop": [None, "qv4mul", "v4qmul", None], + "op_vop": ["qv4mul", "v4qmul"], "vop_type": ['F', 'D'], "vec_types": float_t, }, @@ -452,6 +462,8 @@ group_map = { "compare": compare_formats, "compare2": compare2_formats, "convert": convert_formats, + "hops": hops_formats, + "jump": jump_formats, "lea": lea_formats, "load": load_formats, "mathops": mathops_formats, @@ -522,6 +534,7 @@ def process_opcode(opcode, group): params.update(gm["args"]) inst = {} opcodes[opcode] = inst + #print(f"{opcode:03x}", group) inst["op"] = eval(f'''f"{gm['opcode']}"''', params) mn = eval(f'''f"{gm['mnemonic']}"''', params) inst["mn"] = f'"{mn}"' diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 69d9c0f6f..3f8b9f365 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1830,11 +1830,10 @@ pr_call_mode (progs_t *pr, const dstatement_t *st, int mm_ind) } static pr_pointer_t __attribute__((pure)) -pr_jump_mode (progs_t *pr, const dstatement_t *st) +pr_jump_mode (progs_t *pr, const dstatement_t *st, int jump_ind) { pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, B); - int jump_ind = st->op & 3; pointer_t jump_offs = pr->pr_xstatement; switch (jump_ind) { @@ -2892,228 +2891,9 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) MM(ivec4) = STK(ivec4); break; // 0 0100 - case OP_IFZ_A: - case OP_IFZ_B: - case OP_IFZ_C: - case OP_IFZ_D: - if (!OPC(int)) { - pr->pr_xstatement = pr_jump_mode (pr, st); - st = pr->pr_statements + pr->pr_xstatement; - } - break; - case OP_IFB_A: - case OP_IFB_B: - case OP_IFB_C: - case OP_IFB_D: - if (OPC(int) < 0) { - pr->pr_xstatement = pr_jump_mode (pr, st); - st = pr->pr_statements + pr->pr_xstatement; - } - break; - case OP_IFA_A: - case OP_IFA_B: - case OP_IFA_C: - case OP_IFA_D: - if (OPC(int) > 0) { - pr->pr_xstatement = pr_jump_mode (pr, st); - st = pr->pr_statements + pr->pr_xstatement; - } - break; - case OP_JUMP_A: - case OP_JUMP_B: - case OP_JUMP_C: - case OP_JUMP_D: - pr->pr_xstatement = pr_jump_mode (pr, st); - st = pr->pr_statements + pr->pr_xstatement; - break; // 0 0101 - case OP_IFNZ_A: - case OP_IFNZ_B: - case OP_IFNZ_C: - case OP_IFNZ_D: - if (OPC(int)) { - pr->pr_xstatement = pr_jump_mode (pr, st); - st = pr->pr_statements + pr->pr_xstatement; - } - break; - case OP_IFAE_A: - case OP_IFAE_B: - case OP_IFAE_C: - case OP_IFAE_D: - if (OPC(int) >= 0) { - pr->pr_xstatement = pr_jump_mode (pr, st); - st = pr->pr_statements + pr->pr_xstatement; - } - break; - case OP_IFBE_A: - case OP_IFBE_B: - case OP_IFBE_C: - case OP_IFBE_D: - if (OPC(int) <= 0) { - pr->pr_xstatement = pr_jump_mode (pr, st); - st = pr->pr_statements + pr->pr_xstatement; - } - break; - case OP_RETURN: - int ret_size = st->c & 0x1f; // up to 32 words - if (ret_size) { - mm = pr_return_mode (pr, st, (st->c >> 5) & 7); - memcpy (&R_INT (pr), mm, ret_size * sizeof (*op_a)); - } - pr->pr_xfunction->profile += profile - startprofile; - startprofile = profile; - PR_LeaveFunction (pr, pr->pr_depth == exitdepth); - st = pr->pr_statements + pr->pr_xstatement; - if (pr->pr_depth== exitdepth) { - if (pr->pr_trace && pr->pr_depth <= pr->pr_trace_depth) { - pr->pr_trace = false; - } - goto exit_program; - } - break; - case OP_CALL_B: - case OP_CALL_C: - case OP_CALL_D: - mm = pr_call_mode (pr, st, st->c & 3); - function = mm->func_var; - pr->pr_argc = 0; - // op_c specifies the location for the return value if any - pr->pr_return = op_c; - pr->pr_xfunction->profile += profile - startprofile; - startprofile = profile; - PR_CallFunction (pr, function); - st = pr->pr_statements + pr->pr_xstatement; - break; // 0 0110 - // 0nnn spare - case OP_LEA_A: - case OP_LEA_C: - case OP_LEA_D: - mm = pr_address_mode (pr, st, (st_op - OP_LEA_A)); - op_c->pointer_var = mm - pr->pr_globals; - break; - case OP_LEA_E: - mm = pr_address_mode (pr, st, 4); - op_c->pointer_var = mm - pr->pr_globals; - break; - case OP_CONV: - switch (st->b) { -#include "libs/gamecode/pr_convert.cinc" - default: - PR_RunError (pr, "invalid conversion code: %04o", - st->b); - } - break; - case OP_WITH: - pr_with (pr, st); - break; - case OP_STATE_ft: - { - int self = *pr->globals.self; - int nextthink = pr->fields.nextthink + self; - int frame = pr->fields.frame + self; - int think = pr->fields.think + self; - float time = *pr->globals.time + 0.1; - pr->pr_edict_area[nextthink].float_var = time; - pr->pr_edict_area[frame].float_var = OPA(float); - pr->pr_edict_area[think].func_var = op_b->func_var; - } - break; - case OP_STATE_ftt: - { - int self = *pr->globals.self; - int nextthink = pr->fields.nextthink + self; - int frame = pr->fields.frame + self; - int think = pr->fields.think + self; - float time = *pr->globals.time + OPC(float); - pr->pr_edict_area[nextthink].float_var = time; - pr->pr_edict_area[frame].float_var = OPA(float); - pr->pr_edict_area[think].func_var = op_b->func_var; - } - break; // 0 0111 - case OP_CROSS_F: - { - pr_vec4_t a = loadvec3f (&OPA(float)); - pr_vec4_t b = loadvec3f (&OPB(float)); - pr_vec4_t c = crossf (a, b); - storevec3f (&OPC(float), c); - } - break; - case OP_CDOT_F: - OPC(vec2) = dot2f (OPA(vec2), OPB(vec2)); - break; - case OP_VDOT_F: - { - vec_t d = DotProduct (&OPA(float), - &OPB(float)); - VectorSet (d, d, d, &OPC(float)); - } - break; - case OP_QDOT_F: - OPC(vec4) = dotf (OPA(vec4), OPB(vec4)); - break; - case OP_CMUL_F: - OPC(vec2) = cmulf (OPA(vec2), OPB(vec2)); - break; - case OP_QVMUL_F: - { - pr_vec4_t v = loadvec3f (&OPB(float)); - v = qvmulf (OPA(vec4), v); - storevec3f (&OPC(float), v); - } - break; - case OP_VQMUL_F: - { - pr_vec4_t v = loadvec3f (&OPA(float)); - v = vqmulf (v, OPB(vec4)); - storevec3f (&OPC(float), v); - } - break; - case OP_QMUL_F: - OPC(vec4) = qmulf (OPA(vec4), OPB(vec4)); - break; - case OP_CROSS_D: - { - pr_dvec4_t a = loadvec3d (&OPA(double)); - pr_dvec4_t b = loadvec3d (&OPB(double)); - pr_dvec4_t c = crossd (a, b); - storevec3d (&OPC(double), c); - } - break; - case OP_CDOT_D: - OPC(dvec2) = dot2d (OPA(dvec2), OPB(dvec2)); - break; - case OP_VDOT_D: - { - double d = DotProduct (&OPA(double), - &OPB(double)); - VectorSet (d, d, d, &OPC(double)); - } - break; - case OP_QDOT_D: - OPC(dvec4) = dotd (OPA(dvec4), OPB(dvec4)); - break; - case OP_CMUL_D: - OPC(dvec2) = cmuld (OPA(dvec2), OPB(dvec2)); - break; - case OP_QVMUL_D: - { - pr_dvec4_t v = loadvec3d (&OPB(double)); - v = qvmuld (OPA(dvec4), v); - storevec3d (&OPC(double), v); - } - break; - case OP_VQMUL_D: - { - pr_dvec4_t v = loadvec3d (&OPA(double)); - v = vqmuld (v, OPB(dvec4)); - storevec3d (&OPC(double), v); - } - break; - case OP_QMUL_D: - OPC(dvec4) = qmuld (OPA(dvec4), OPB(dvec4)); - break; #define OP_cmp_1(OP, T, rt, cmp, ct) \ case OP_##OP##_##T##_1: \ @@ -3330,6 +3110,46 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OP_uop_T (BITNOT, I, int, ivec2, ivec4, ~); // 1 1001 OP_cmp_T (LT, u, int, ivec2, ivec4, <, uint, uivec2, uivec4); + case OP_JUMP_A: + case OP_JUMP_B: + case OP_JUMP_C: + case OP_JUMP_D: + pr->pr_xstatement = pr_jump_mode (pr, st, st_op - OP_JUMP_A); + st = pr->pr_statements + pr->pr_xstatement; + break; + OP_cmp_T (LT, U, long, lvec2, lvec4, <, ulong, ulvec2, ulvec4); + case OP_RETURN: + int ret_size = st->c & 0x1f; // up to 32 words + if (ret_size) { + mm = pr_return_mode (pr, st, (st->c >> 5) & 7); + memcpy (&R_INT (pr), mm, ret_size * sizeof (*op_a)); + } + pr->pr_xfunction->profile += profile - startprofile; + startprofile = profile; + PR_LeaveFunction (pr, pr->pr_depth == exitdepth); + st = pr->pr_statements + pr->pr_xstatement; + if (pr->pr_depth== exitdepth) { + if (pr->pr_trace && pr->pr_depth <= pr->pr_trace_depth) { + pr->pr_trace = false; + } + goto exit_program; + } + break; + case OP_CALL_B: + case OP_CALL_C: + case OP_CALL_D: + mm = pr_call_mode (pr, st, st->c & 3); + function = mm->func_var; + pr->pr_argc = 0; + // op_c specifies the location for the return value if any + pr->pr_return = op_c; + pr->pr_xfunction->profile += profile - startprofile; + startprofile = profile; + PR_CallFunction (pr, function); + st = pr->pr_statements + pr->pr_xstatement; + break; + // 1 1010 + OP_cmp_T (GT, u, int, ivec2, ivec4, >, uint, uivec2, uivec4); case OP_SWIZZLE_F: OPC(ivec4) = pr_swizzle_f (OPA(ivec4), st->b); break; @@ -3342,7 +3162,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_SCALE_F_4: OPC(vec4) = OPA(vec4) * OPB(float); break; - OP_cmp_T (LT, U, long, lvec2, lvec4, <, ulong, ulvec2, ulvec4); + OP_cmp_T (GT, U, long, lvec2, lvec4, >, ulong, ulvec2, ulvec4); case OP_SWIZZLE_D: OPC(lvec4) = pr_swizzle_d (OPA(lvec4), st->b); break; @@ -3355,53 +3175,89 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_SCALE_D_4: OPC(dvec4) = OPA(dvec4) * OPB(double); break; - // 1 1010 - OP_cmp_T (GT, u, int, ivec2, ivec4, >, uint, uivec2, uivec4); - // spare - OP_cmp_T (GT, U, long, lvec2, lvec4, >, ulong, ulvec2, ulvec4); - // spare // 1 1011 - // 00nn spare - case OP_ANY_2: - OPC(int) = any2i (OPA(ivec2)); - break; - case OP_ANY_3: + case OP_CROSS_F: { - __auto_type v = loadvec3i (&OPA(int)); - OPC(int) = any4i (v); + pr_vec4_t a = loadvec3f (&OPA(float)); + pr_vec4_t b = loadvec3f (&OPB(float)); + pr_vec4_t c = crossf (a, b); + storevec3f (&OPC(float), c); } break; - case OP_ANY_4: - OPC(int) = any4i (OPA(ivec4)); + case OP_CDOT_F: + OPC(vec2) = dot2f (OPA(vec2), OPB(vec2)); break; - // spare - case OP_ALL_2: - OPC(int) = all2i (OPA(ivec2)); - break; - case OP_ALL_3: + case OP_VDOT_F: { - __auto_type v = loadvec3i (&OPA(int)); - v[3] = -1; - OPC(int) = all4i (v); + vec_t d = DotProduct (&OPA(float), + &OPB(float)); + VectorSet (d, d, d, &OPC(float)); } break; - case OP_ALL_4: - OPC(int) = all4i (OPA(ivec4)); + case OP_QDOT_F: + OPC(vec4) = dotf (OPA(vec4), OPB(vec4)); break; - // spare - case OP_NONE_2: - OPC(int) = none2i (OPA(ivec2)); + case OP_CMUL_F: + OPC(vec2) = cmulf (OPA(vec2), OPB(vec2)); break; - case OP_NONE_3: + case OP_QVMUL_F: { - __auto_type v = loadvec3i (&OPA(int)); - OPC(int) = none4i (v); + pr_vec4_t v = loadvec3f (&OPB(float)); + v = qvmulf (OPA(vec4), v); + storevec3f (&OPC(float), v); } break; - case OP_NONE_4: - OPC(int) = none4i (OPA(ivec4)); + case OP_VQMUL_F: + { + pr_vec4_t v = loadvec3f (&OPA(float)); + v = vqmulf (v, OPB(vec4)); + storevec3f (&OPC(float), v); + } + break; + case OP_QMUL_F: + OPC(vec4) = qmulf (OPA(vec4), OPB(vec4)); + break; + case OP_CROSS_D: + { + pr_dvec4_t a = loadvec3d (&OPA(double)); + pr_dvec4_t b = loadvec3d (&OPB(double)); + pr_dvec4_t c = crossd (a, b); + storevec3d (&OPC(double), c); + } + break; + case OP_CDOT_D: + OPC(dvec2) = dot2d (OPA(dvec2), OPB(dvec2)); + break; + case OP_VDOT_D: + { + double d = DotProduct (&OPA(double), + &OPB(double)); + VectorSet (d, d, d, &OPC(double)); + } + break; + case OP_QDOT_D: + OPC(dvec4) = dotd (OPA(dvec4), OPB(dvec4)); + break; + case OP_CMUL_D: + OPC(dvec2) = cmuld (OPA(dvec2), OPB(dvec2)); + break; + case OP_QVMUL_D: + { + pr_dvec4_t v = loadvec3d (&OPB(double)); + v = qvmuld (OPA(dvec4), v); + storevec3d (&OPC(double), v); + } + break; + case OP_VQMUL_D: + { + pr_dvec4_t v = loadvec3d (&OPA(double)); + v = vqmuld (v, OPB(dvec4)); + storevec3d (&OPC(double), v); + } + break; + case OP_QMUL_D: + OPC(dvec4) = qmuld (OPA(dvec4), OPB(dvec4)); break; - // 1 1100 OP_op_T (BITAND, L, long, lvec2, lvec4, &); OP_op_T (BITOR, L, long, lvec2, lvec4, |); @@ -3409,9 +3265,6 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OP_uop_T (BITNOT, L, long, lvec2, lvec4, ~); // 1 1101 OP_cmp_T (GE, u, int, ivec2, ivec4, >=, uint, uivec2, uivec4); - case OP_QV4MUL_F: - OPC(vec4) = qvmulf (OPA(vec4), OPB(vec4)); - break; case OP_MOVE_I: memmove (op_c, op_a, st->b * sizeof (pr_type_t)); break; @@ -3423,10 +3276,15 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) memmove (pr->pr_globals + OPC(int), pr->pr_globals + OPA(int), st->b * sizeof (pr_type_t)); break; - OP_cmp_T (GE, U, long, lvec2, lvec4, >=, ulong, ulvec2, ulvec4); - case OP_QV4MUL_D: - OPC(dvec4) = qvmuld (OPA(dvec4), OPB(dvec4)); + case OP_CONV: + switch (st->b) { +#include "libs/gamecode/pr_convert.cinc" + default: + PR_RunError (pr, "invalid conversion code: %04o", + st->b); + } break; + OP_cmp_T (GE, U, long, lvec2, lvec4, >=, ulong, ulvec2, ulvec4); case OP_MEMSET_I: pr_memset (op_c, OPA(int), st->b); break; @@ -3436,19 +3294,106 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_MEMSET_PI: pr_memset (pr->pr_globals + OPC(int), OPA(int), st->b); break; + case OP_WITH: + pr_with (pr, st); + break; // 1 1110 OP_cmp_T (LE, u, int, ivec2, ivec4, <=, uint, uivec2, uivec4); + case OP_IFZ: + if (!OPC(int)) { + pr->pr_xstatement = pr_jump_mode (pr, st, 0); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_IFB: + if (OPC(int) < 0) { + pr->pr_xstatement = pr_jump_mode (pr, st, 0); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_IFA: + if (OPC(int) > 0) { + pr->pr_xstatement = pr_jump_mode (pr, st, 0); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_STATE_ft: + { + int self = *pr->globals.self; + int nextthink = pr->fields.nextthink + self; + int frame = pr->fields.frame + self; + int think = pr->fields.think + self; + float time = *pr->globals.time + 0.1; + pr->pr_edict_area[nextthink].float_var = time; + pr->pr_edict_area[frame].float_var = OPA(float); + pr->pr_edict_area[think].func_var = op_b->func_var; + } + break; + OP_cmp_T (LE, U, long, lvec2, lvec4, <=, ulong, ulvec2, ulvec4); + case OP_IFNZ: + if (OPC(int)) { + pr->pr_xstatement = pr_jump_mode (pr, st, 0); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_IFAE: + if (OPC(int) >= 0) { + pr->pr_xstatement = pr_jump_mode (pr, st, 0); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_IFBE: + if (OPC(int) <= 0) { + pr->pr_xstatement = pr_jump_mode (pr, st, 0); + st = pr->pr_statements + pr->pr_xstatement; + } + break; + case OP_STATE_ftt: + { + int self = *pr->globals.self; + int nextthink = pr->fields.nextthink + self; + int frame = pr->fields.frame + self; + int think = pr->fields.think + self; + float time = *pr->globals.time + OPC(float); + pr->pr_edict_area[nextthink].float_var = time; + pr->pr_edict_area[frame].float_var = OPA(float); + pr->pr_edict_area[think].func_var = op_b->func_var; + } + break; + // 1 1111 + case OP_LEA_A: + case OP_LEA_C: + case OP_LEA_D: + mm = pr_address_mode (pr, st, (st_op - OP_LEA_A)); + op_c->pointer_var = mm - pr->pr_globals; + break; + case OP_LEA_E: + mm = pr_address_mode (pr, st, 4); + op_c->pointer_var = mm - pr->pr_globals; + break; + case OP_QV4MUL_F: + OPC(vec4) = qvmulf (OPA(vec4), OPB(vec4)); + break; case OP_V4QMUL_F: OPC(vec4) = vqmulf (OPA(vec4), OPB(vec4)); break; - // spare - OP_cmp_T (LE, U, long, lvec2, lvec4, <=, ulong, ulvec2, ulvec4); + case OP_QV4MUL_D: + OPC(dvec4) = qvmuld (OPA(dvec4), OPB(dvec4)); + break; case OP_V4QMUL_D: OPC(dvec4) = vqmuld (OPA(dvec4), OPB(dvec4)); break; - // spare - // 1 1111 - // spare + // 10nn spare + // 1100 spare + // 1101 spare + // 1110 spare + case OP_HOPS: + switch (st->b) { + default: + PR_RunError (pr, "invalid hops code: %04o", + st->b); + } + break; default: PR_RunError (pr, "Bad opcode o%03o", st->op & OP_MASK); } diff --git a/libs/gamecode/test/test-bitops.c b/libs/gamecode/test/test-bitops.c index a3121eb46..b692223d7 100644 --- a/libs/gamecode/test/test-bitops.c +++ b/libs/gamecode/test/test-bitops.c @@ -26,7 +26,7 @@ static dstatement_t int_bitop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 24 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 24, -1, 24 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 24 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 24 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 24, 1 }, @@ -42,7 +42,7 @@ static dstatement_t int_bitop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 24 }, // index //loop: { OP(0, 0, 0, OP_LEA_C), 24, -2, 24 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 24 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 24 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 24, 1 }, @@ -107,7 +107,7 @@ static dstatement_t long_bitop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 48 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 48, -2, 48 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 48 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 48 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 48, 1 }, @@ -123,7 +123,7 @@ static dstatement_t long_bitop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 48 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 48, -4, 48 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 48 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 48 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 48, 1 }, diff --git a/libs/gamecode/test/test-conv0.c b/libs/gamecode/test/test-conv0.c index 2f0533361..3b6e06359 100644 --- a/libs/gamecode/test/test-conv0.c +++ b/libs/gamecode/test/test-conv0.c @@ -54,7 +54,7 @@ static dstatement_t int_conv_1_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 80, -1, 80 }, // dec index { OP(0, 0, 0, OP_LEA_C), 81, -2, 81 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 80 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, @@ -75,7 +75,7 @@ static dstatement_t int_conv_2_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 80, -2, 80 }, // dec index { OP(0, 0, 0, OP_LEA_C), 81, -4, 81 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 80 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, diff --git a/libs/gamecode/test/test-conv1.c b/libs/gamecode/test/test-conv1.c index 6233b83f3..663604205 100644 --- a/libs/gamecode/test/test-conv1.c +++ b/libs/gamecode/test/test-conv1.c @@ -54,7 +54,7 @@ static dstatement_t float_conv_1_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 80, -1, 80 }, // dec index { OP(0, 0, 0, OP_LEA_C), 81, -2, 81 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 80 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, @@ -75,7 +75,7 @@ static dstatement_t float_conv_2_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 80, -2, 80 }, // dec index { OP(0, 0, 0, OP_LEA_C), 81, -4, 81 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 80 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, diff --git a/libs/gamecode/test/test-conv2.c b/libs/gamecode/test/test-conv2.c index f3a81a6ad..0dd4f5d41 100644 --- a/libs/gamecode/test/test-conv2.c +++ b/libs/gamecode/test/test-conv2.c @@ -70,7 +70,7 @@ static dstatement_t long_conv_1_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 112, -1, 112 }, // dec index { OP(0, 0, 0, OP_LEA_C), 113, -2, 113 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 112 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, @@ -91,7 +91,7 @@ static dstatement_t long_conv_2_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 112, -2, 112 }, // dec index { OP(0, 0, 0, OP_LEA_C), 113, -4, 113 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 112 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, diff --git a/libs/gamecode/test/test-conv3.c b/libs/gamecode/test/test-conv3.c index ea6989dda..7ea316d8b 100644 --- a/libs/gamecode/test/test-conv3.c +++ b/libs/gamecode/test/test-conv3.c @@ -70,7 +70,7 @@ static dstatement_t double_conv_1_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 112, -1, 112 }, // dec index { OP(0, 0, 0, OP_LEA_C), 113, -2, 113 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 112 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, @@ -91,7 +91,7 @@ static dstatement_t double_conv_2_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 112, -2, 112 }, // dec index { OP(0, 0, 0, OP_LEA_C), 113, -4, 113 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 112 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, diff --git a/libs/gamecode/test/test-conv4.c b/libs/gamecode/test/test-conv4.c index 0f7460a6a..246b4bec3 100644 --- a/libs/gamecode/test/test-conv4.c +++ b/libs/gamecode/test/test-conv4.c @@ -54,7 +54,7 @@ static dstatement_t uint_conv_1_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 80, -1, 80 }, // dec index { OP(0, 0, 0, OP_LEA_C), 81, -2, 81 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 80 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, @@ -75,7 +75,7 @@ static dstatement_t uint_conv_2_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 80, -2, 80 }, // dec index { OP(0, 0, 0, OP_LEA_C), 81, -4, 81 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 80 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, diff --git a/libs/gamecode/test/test-conv5.c b/libs/gamecode/test/test-conv5.c index 3713cd159..fe75e0ff2 100644 --- a/libs/gamecode/test/test-conv5.c +++ b/libs/gamecode/test/test-conv5.c @@ -54,7 +54,7 @@ static dstatement_t bool32_conv_1_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 80, -1, 80 }, // dec index { OP(0, 0, 0, OP_LEA_C), 81, -2, 81 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 80 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, @@ -75,7 +75,7 @@ static dstatement_t bool32_conv_2_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 80, -2, 80 }, // dec index { OP(0, 0, 0, OP_LEA_C), 81, -4, 81 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 80 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 80 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 80, 1 }, { OP(0, 0, 0, OP_WITH), 4, 81, 2 }, diff --git a/libs/gamecode/test/test-conv6.c b/libs/gamecode/test/test-conv6.c index 7fd62c1ac..b32cfc537 100644 --- a/libs/gamecode/test/test-conv6.c +++ b/libs/gamecode/test/test-conv6.c @@ -70,7 +70,7 @@ static dstatement_t ulong_conv_1_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 112, -1, 112 }, // dec index { OP(0, 0, 0, OP_LEA_C), 113, -2, 113 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 112 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, @@ -91,7 +91,7 @@ static dstatement_t ulong_conv_2_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 112, -2, 112 }, // dec index { OP(0, 0, 0, OP_LEA_C), 113, -4, 113 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 112 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, diff --git a/libs/gamecode/test/test-conv7.c b/libs/gamecode/test/test-conv7.c index c8f9354c0..cbc2306e0 100644 --- a/libs/gamecode/test/test-conv7.c +++ b/libs/gamecode/test/test-conv7.c @@ -70,7 +70,7 @@ static dstatement_t bool64_conv_1_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 112, -1, 112 }, // dec index { OP(0, 0, 0, OP_LEA_C), 113, -2, 113 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 112 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, @@ -91,7 +91,7 @@ static dstatement_t bool64_conv_2_statements[] = { //loop: { OP(0, 0, 0, OP_LEA_C), 112, -2, 112 }, // dec index { OP(0, 0, 0, OP_LEA_C), 113, -4, 113 }, // dec index for 64-bits - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 112 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 112 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 112, 1 }, { OP(0, 0, 0, OP_WITH), 4, 113, 2 }, diff --git a/libs/gamecode/test/test-double.c b/libs/gamecode/test/test-double.c index 239630034..33bd4ff7a 100644 --- a/libs/gamecode/test/test-double.c +++ b/libs/gamecode/test/test-double.c @@ -30,7 +30,7 @@ static dstatement_t double_binop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 64, -2, 64 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 64 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, { OP(1, 1, 1, OP_MUL_D_1), 0, 8, 16 }, @@ -46,7 +46,7 @@ static dstatement_t double_binop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 64, -4, 64 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 64 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, { OP(1, 1, 1, OP_MUL_D_2), 0, 8, 16 }, @@ -129,7 +129,7 @@ static dstatement_t double_cossin_statements[] = { { OP(0, 0, 0, OP_DIV_D_2), 40, 16, 40 }, // xn /= f { OP(0, 0, 0, OP_ADD_D_2), 16, 24, 16 }, // f += inc { OP(0, 0, 0, OP_LT_D_1), 16, 30, 46 }, // f0 < fmax - { OP(0, 0, 0, OP_IFNZ_A), -7, 0, 46 }, // f0 < fmax + { OP(0, 0, 0, OP_IFNZ), -7, 0, 46 }, // f0 < fmax }; static pr_dvec4_t double_cmpop_init[] = { @@ -161,7 +161,7 @@ static dstatement_t double_cmpop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 64, -2, 64 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 64 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, { OP(1, 1, 1, OP_EQ_D_1), 0, 8, 16 }, @@ -177,7 +177,7 @@ static dstatement_t double_cmpop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 64, -4, 64 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 64 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, { OP(1, 1, 1, OP_EQ_D_2), 0, 8, 16 }, diff --git a/libs/gamecode/test/test-float.c b/libs/gamecode/test/test-float.c index 626f4aaa0..576518128 100644 --- a/libs/gamecode/test/test-float.c +++ b/libs/gamecode/test/test-float.c @@ -30,7 +30,7 @@ static dstatement_t float_binop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 32, -1, 32 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 32 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, { OP(1, 1, 1, OP_MUL_F_1), 0, 4, 8 }, @@ -46,7 +46,7 @@ static dstatement_t float_binop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // index //loop: { OP(0, 0, 0, OP_LEA_C), 32, -2, 32 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 32 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, { OP(1, 1, 1, OP_MUL_F_2), 0, 4, 8 }, @@ -129,7 +129,7 @@ static dstatement_t float_cossin_statements[] = { { OP(0, 0, 0, OP_DIV_F_2), 20, 8, 20 }, // xn /= f { OP(0, 0, 0, OP_ADD_F_2), 8, 12, 8 }, // f += inc { OP(0, 0, 0, OP_LT_F_1), 8, 15, 23 }, // f0 < fmax - { OP(0, 0, 0, OP_IFNZ_A), -7, 0, 23 }, // f0 < fmax + { OP(0, 0, 0, OP_IFNZ), -7, 0, 23 }, // f0 < fmax }; static pr_vec4_t float_cmpop_init[] = { @@ -161,7 +161,7 @@ static dstatement_t float_cmpop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 32, -1, 32 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 32 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, { OP(1, 1, 1, OP_EQ_F_1), 0, 4, 8 }, @@ -177,7 +177,7 @@ static dstatement_t float_cmpop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // index //loop: { OP(0, 0, 0, OP_LEA_C), 32, -2, 32 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 32 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, { OP(1, 1, 1, OP_EQ_F_2), 0, 4, 8 }, diff --git a/libs/gamecode/test/test-int.c b/libs/gamecode/test/test-int.c index f8b4a6a5e..6ca0dc928 100644 --- a/libs/gamecode/test/test-int.c +++ b/libs/gamecode/test/test-int.c @@ -28,7 +28,7 @@ static dstatement_t int_binop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 32, -1, 32 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 32 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, { OP(1, 1, 1, OP_MUL_I_1), 0, 4, 8 }, @@ -44,7 +44,7 @@ static dstatement_t int_binop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // index //loop: { OP(0, 0, 0, OP_LEA_C), 32, -2, 32 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 32 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, { OP(1, 1, 1, OP_MUL_I_2), 0, 4, 8 }, @@ -121,7 +121,7 @@ static dstatement_t int_cmpop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 32, -1, 32 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 32 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, { OP(1, 1, 1, OP_EQ_I_1), 0, 4, 8 }, @@ -137,7 +137,7 @@ static dstatement_t int_cmpop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // index //loop: { OP(0, 0, 0, OP_LEA_C), 32, -2, 32 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 32 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, { OP(1, 1, 1, OP_EQ_I_2), 0, 4, 8 }, diff --git a/libs/gamecode/test/test-long.c b/libs/gamecode/test/test-long.c index 36d62845e..b5b021e17 100644 --- a/libs/gamecode/test/test-long.c +++ b/libs/gamecode/test/test-long.c @@ -30,7 +30,7 @@ static dstatement_t long_binop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 64, -2, 64 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 64 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, { OP(1, 1, 1, OP_MUL_L_1), 0, 8, 16 }, @@ -46,7 +46,7 @@ static dstatement_t long_binop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 64, -4, 64 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 64 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, { OP(1, 1, 1, OP_MUL_L_2), 0, 8, 16 }, @@ -123,7 +123,7 @@ static dstatement_t long_cmpop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 64, -2, 64 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 64 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, { OP(1, 1, 1, OP_EQ_L_1), 0, 8, 16 }, @@ -139,7 +139,7 @@ static dstatement_t long_cmpop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 64, -4, 64 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 64 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, { OP(1, 1, 1, OP_EQ_L_2), 0, 8, 16 }, diff --git a/libs/gamecode/test/test-string.c b/libs/gamecode/test/test-string.c index a723eebb7..ceb716570 100644 --- a/libs/gamecode/test/test-string.c +++ b/libs/gamecode/test/test-string.c @@ -36,7 +36,7 @@ static dstatement_t string_statements[] = { { OP(0, 0, 0, OP_LEA_A), 24, 0, 6 }, // init k // for (i = 4; i-- > 0; ) { { OP(0, 0, 0, OP_LEA_A), 4, 0, 4 }, - { OP(0, 0, 0, OP_IFA_A), 2, 0, 4 }, + { OP(0, 0, 0, OP_IFA), 2, 0, 4 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_LEA_C), 4, -1, 4 }, // dec i @@ -45,7 +45,7 @@ static dstatement_t string_statements[] = { // for (j = 4; j-- > 0; ) { { OP(0, 0, 0, OP_LEA_A), 4, 0, 5 }, // init j - { OP(0, 0, 0, OP_IFA_A), 2, 0, 5 }, + { OP(0, 0, 0, OP_IFA), 2, 0, 5 }, { OP(0, 0, 0, OP_JUMP_A), -6, 0, 0 }, { OP(0, 0, 0, OP_LEA_C), 5, -1, 5 }, // dec j diff --git a/libs/gamecode/test/test-unsigned.c b/libs/gamecode/test/test-unsigned.c index de9fd3bfa..e37a84d94 100644 --- a/libs/gamecode/test/test-unsigned.c +++ b/libs/gamecode/test/test-unsigned.c @@ -28,7 +28,7 @@ static dstatement_t uint_cmpop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 32, -1, 32 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 32 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, // no unsigned EQ (redundant) @@ -44,7 +44,7 @@ static dstatement_t uint_cmpop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // index //loop: { OP(0, 0, 0, OP_LEA_C), 32, -2, 32 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 32 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 32 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, // no unsigned EQ (redundant) @@ -121,7 +121,7 @@ static dstatement_t ulong_cmpop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 64, -2, 64 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 64 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, // no unsigned EQ (redundant) @@ -137,7 +137,7 @@ static dstatement_t ulong_cmpop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 64, -4, 64 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 64 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 64 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, // no unsigned EQ (redundant) @@ -216,7 +216,7 @@ static dstatement_t uint_shiftop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 36 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 36, -1, 36 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 36 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 36 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 36, 1 }, { OP(1, 1, 1, OP_SHL_I_1), 0, 4, 12 }, @@ -232,7 +232,7 @@ static dstatement_t uint_shiftop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 4, 0, 36 }, // index //loop: { OP(0, 0, 0, OP_LEA_C), 36, -2, 36 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 36 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 36 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 36, 1 }, { OP(1, 1, 1, OP_SHL_I_2), 0, 4, 12 }, @@ -319,7 +319,7 @@ static dstatement_t ulong_shiftop_1_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 72 }, // init index //loop: { OP(0, 0, 0, OP_LEA_C), 72, -2, 72 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 72 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 72 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 72, 1 }, { OP(1, 1, 1, OP_SHL_L_1), 0, 8, 24 }, @@ -335,7 +335,7 @@ static dstatement_t ulong_shiftop_2_statements[] = { { OP(0, 0, 0, OP_LEA_A), 8, 0, 72 }, // index //loop: { OP(0, 0, 0, OP_LEA_C), 72, -4, 72 }, // dec index - { OP(0, 0, 0, OP_IFAE_A), 2, 0, 72 }, + { OP(0, 0, 0, OP_IFAE), 2, 0, 72 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_WITH), 4, 72, 1 }, { OP(1, 1, 1, OP_SHL_L_2), 0, 8, 24 }, From 7ea12b3ff993cf65c4c0e838848b72dd8ae4bcff Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 16 Jan 2022 16:27:33 +0900 Subject: [PATCH 115/360] [gamecode] Implement the HOPS sub-instructions In the end, I decided any/all/none should be separate from the other horizontal ops, if I even do them (can be implemented by first converting to bool, then using the appropriate horizontal operation (& | etc). --- libs/gamecode/Makemodule.am | 13 ++++++++- libs/gamecode/hops.py | 55 +++++++++++++++++++++++++++++++++++++ libs/gamecode/pr_exec.c | 4 +++ 3 files changed, 71 insertions(+), 1 deletion(-) create mode 100644 libs/gamecode/hops.py diff --git a/libs/gamecode/Makemodule.am b/libs/gamecode/Makemodule.am index ea9ae11b1..dbffb47b3 100644 --- a/libs/gamecode/Makemodule.am +++ b/libs/gamecode/Makemodule.am @@ -34,7 +34,14 @@ libs/gamecode/pr_opcode.lo: libs/gamecode/pr_opcode.c ${pr_opcode_src} convert_py = $(srcdir)/libs/gamecode/convert.py pr_convert_cinc = $(top_builddir)/libs/gamecode/pr_convert.cinc -BUILT_SOURCES += $(pr_opcode_cinc) $(pr_opcode_hinc) $(pr_convert_cinc) +hops_py = $(srcdir)/libs/gamecode/hops.py +pr_hops_cinc = $(top_builddir)/libs/gamecode/pr_hops.cinc + +BUILT_SOURCES += \ + $(pr_opcode_cinc) \ + $(pr_opcode_hinc) \ + $(pr_convert_cinc) \ + $(pr_hops_cinc) $(pr_opcode_cinc): $(opcodes_py) $(V_PY)$(PYTHON) $(opcodes_py) table > $(pr_opcode_cinc).t && \ @@ -48,3 +55,7 @@ $(pr_opcode_hinc): $(opcodes_py) $(pr_convert_cinc): $(convert_py) $(V_PY)$(PYTHON) $(convert_py) table > $(pr_convert_cinc).t && \ $(am__mv) $(pr_convert_cinc).t $(pr_convert_cinc) + +$(pr_hops_cinc): $(hops_py) + $(V_PY)$(PYTHON) $(hops_py) table > $(pr_hops_cinc).t && \ + $(am__mv) $(pr_hops_cinc).t $(pr_hops_cinc) diff --git a/libs/gamecode/hops.py b/libs/gamecode/hops.py new file mode 100644 index 000000000..04891036b --- /dev/null +++ b/libs/gamecode/hops.py @@ -0,0 +1,55 @@ +print("""// encoding is tssooo +// t = 0: 32-bit, t = 1: 64-bit +// ss = 00: reserved +// ss = 01: 2 components +// ss = 10: 3 components +// ss = 11: 4 components +// ooo = 000: and +// ooo = 001: or +// ooo = 010: xor +// ooo = 011: add.i +// ooo = 100: nand +// ooo = 101: nor +// ooo = 110: xnor +// ooo = 111: add.f +""") +#for vec3 +types = [ + ["int", "int", "int", "int", "int", "int", "int", "float"], + ["long", "long", "long", "long", "long", "long", "long", "double"] +] +#does not include size (2 or 4, 3 is special) +vec_types = [ + ["ivec", "ivec", "ivec", "ivec", "ivec", "ivec", "ivec", "vec"], + ["lvec", "lvec", "lvec", "lvec", "lvec", "lvec", "lvec", "dvec"] +] +operators = ["&", "|", "^", "+"] + +def case_str(type, width, op): + case = (type << 5) | (width << 3) | (op) + return f"case {case:03o}:" + +def src_str(type, width, op): + if width & 1: + return f"OPA({vec_types[type][op]}{width+1})" + else: + return f"OPA({types[type][op]})" + +def dst_str(type, width, op): + return f"OPC({types[type][op]})" + +def hop_str(type, width, op): + return f"OP_hop{width+1}" + +for type in range(2): + for width in range(1, 4): # 0 is reserved + for opcode in range(8): + case = case_str(type, width, opcode) + src = src_str(type, width, opcode) + dst = dst_str(type, width, opcode) + hop = hop_str(type, width, opcode) + op = operators[opcode & 3] + if width == 2: + print(f"{case} {dst} = {hop} (&{src}, {op}); break;") + else: + print(f"{case} {dst} = {hop} ({src}, {op}); break;") diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 3f8b9f365..8a0429807 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -3387,8 +3387,12 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) // 1100 spare // 1101 spare // 1110 spare +#define OP_hop2(vec, op) ((vec)[0] op (vec)[1]) +#define OP_hop3(vec, op) ((vec)[0] op (vec)[1] op (vec)[2]) +#define OP_hop4(vec, op) ((vec)[0] op (vec)[1] op (vec)[2] op (vec)[3]) case OP_HOPS: switch (st->b) { +#include "libs/gamecode/pr_hops.cinc" default: PR_RunError (pr, "invalid hops code: %04o", st->b); From d57712975e644d662623e5cdfd78466b477a83f7 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 16 Jan 2022 18:46:29 +0900 Subject: [PATCH 116/360] [gamecode] Add tests for the hops instructions And, of course, fix a bug in the inverted hops (yay for tests). --- libs/gamecode/hops.py | 2 +- libs/gamecode/test/Makemodule.am | 8 +- libs/gamecode/test/test-hops.c | 166 +++++++++++++++++++++++++++++++ 3 files changed, 174 insertions(+), 2 deletions(-) create mode 100644 libs/gamecode/test/test-hops.c diff --git a/libs/gamecode/hops.py b/libs/gamecode/hops.py index 04891036b..634decc47 100644 --- a/libs/gamecode/hops.py +++ b/libs/gamecode/hops.py @@ -39,7 +39,7 @@ def dst_str(type, width, op): return f"OPC({types[type][op]})" def hop_str(type, width, op): - return f"OP_hop{width+1}" + return f"{'~' if op & 4 and op != 7 else ''}OP_hop{width+1}" for type in range(2): for width in range(1, 4): # 0 is reserved diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index 0788861f8..d63023468 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -10,6 +10,7 @@ libs_gamecode_tests = \ libs/gamecode/test/test-conv7 \ libs/gamecode/test/test-double \ libs/gamecode/test/test-float \ + libs/gamecode/test/test-hops \ libs/gamecode/test/test-int \ libs/gamecode/test/test-lea \ libs/gamecode/test/test-load \ @@ -82,13 +83,18 @@ libs_gamecode_test_test_conv7_DEPENDENCIES= $(test_gamecode_libs) libs_gamecode_test_test_double_SOURCES= \ libs/gamecode/test/test-double.c libs_gamecode_test_test_double_LDADD= $(test_gamecode_libs) -libs_gamecode_test_test_double_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_double_DEPENDENCIES=$(test_gamecode_libs) libs_gamecode_test_test_float_SOURCES= \ libs/gamecode/test/test-float.c libs_gamecode_test_test_float_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_float_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_hops_SOURCES= \ + libs/gamecode/test/test-hops.c +libs_gamecode_test_test_hops_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_hops_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_int_SOURCES= \ libs/gamecode/test/test-int.c libs_gamecode_test_test_int_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-hops.c b/libs/gamecode/test/test-hops.c new file mode 100644 index 000000000..34d14fe2d --- /dev/null +++ b/libs/gamecode/test/test-hops.c @@ -0,0 +1,166 @@ +#include "head.c" + +#include "QF/mathlib.h" + +static pr_uivec4_t uint_hop_init[7] = { + { 0x0000ff00, 0x0000f0f0, 0x0000cccc, 0x0000aaaa }, +}; + +static pr_uivec4_t uint_hop_expect[] = { + { 0x0000ff00, 0x0000f0f0, 0x0000cccc, 0x0000aaaa }, + { 0x00008888, 0x0000eeee, 0x00006666, 0x00017776 }, + { 0xffff7777, 0xffff1111, 0xffff9999, 0 }, + { 0x00008080, 0x0000fefe, 0x00009696, 0x00026866 }, + { 0xffff7f7f, 0xffff0101, 0xffff6969, 0 }, + { 0x00008000, 0x0000fffe, 0x00006996, 0x00036766 }, + { 0xffff7fff, 0xffff0001, 0xffff9669, 0 }, +}; + +static dstatement_t uint_hop_statements[] = { + { OP(0, 0, 0, OP_WITH), 0, 4, 1 }, + { OP(0, 0, 0, OP_WITH), 0, 12, 2 }, + { OP(0, 0, 0, OP_WITH), 0, 20, 3 }, + + { OP(0, 0, 1, OP_HOPS), 2, 010, 0 }, + { OP(0, 0, 1, OP_HOPS), 2, 011, 1 }, + { OP(0, 0, 1, OP_HOPS), 2, 012, 2 }, + { OP(0, 0, 1, OP_HOPS), 2, 013, 3 }, + { OP(0, 0, 1, OP_HOPS), 2, 014, 4 }, + { OP(0, 0, 1, OP_HOPS), 2, 015, 5 }, + { OP(0, 0, 1, OP_HOPS), 2, 016, 6 }, + + { OP(0, 0, 2, OP_HOPS), 1, 020, 0 }, + { OP(0, 0, 2, OP_HOPS), 1, 021, 1 }, + { OP(0, 0, 2, OP_HOPS), 1, 022, 2 }, + { OP(0, 0, 2, OP_HOPS), 1, 023, 3 }, + { OP(0, 0, 2, OP_HOPS), 1, 024, 4 }, + { OP(0, 0, 2, OP_HOPS), 1, 025, 5 }, + { OP(0, 0, 2, OP_HOPS), 1, 026, 6 }, + + { OP(0, 0, 3, OP_HOPS), 0, 030, 0 }, + { OP(0, 0, 3, OP_HOPS), 0, 031, 1 }, + { OP(0, 0, 3, OP_HOPS), 0, 032, 2 }, + { OP(0, 0, 3, OP_HOPS), 0, 033, 3 }, + { OP(0, 0, 3, OP_HOPS), 0, 034, 4 }, + { OP(0, 0, 3, OP_HOPS), 0, 035, 5 }, + { OP(0, 0, 3, OP_HOPS), 0, 036, 6 }, +}; + +static pr_ulvec4_t ulong_hop_init[7] = { + { UINT64_C(0x00ff00000000), UINT64_C(0x0f0f00000000), + UINT64_C(0x333300000000), UINT64_C(0x555500000000) }, +}; + +static pr_ulvec4_t ulong_hop_expect[] = { + { UINT64_C(0x000000ff00000000), UINT64_C(0x00000f0f00000000), + UINT64_C(0x0000333300000000), UINT64_C(0x0000555500000000) }, + { UINT64_C(0x0000111100000000), UINT64_C(0x0000777700000000), + UINT64_C(0x0000666600000000), UINT64_C(0x0000888800000000) }, + { UINT64_C(0xffffeeeeffffffff), UINT64_C(0xffff8888ffffffff), + UINT64_C(0xffff9999ffffffff), 0 }, + { UINT64_C(0x0000010100000000), UINT64_C(0x00007f7f00000000), + UINT64_C(0x0000696900000000), UINT64_C(0x0000979700000000) }, + { UINT64_C(0xfffffefeffffffff), UINT64_C(0xffff8080ffffffff), + UINT64_C(0xffff9696ffffffff), 0 }, + { UINT64_C(0x0000000100000000), UINT64_C(0x00007fff00000000), + UINT64_C(0x0000699600000000), UINT64_C(0x0000989600000000) }, + { UINT64_C(0xfffffffeffffffff), UINT64_C(0xffff8000ffffffff), + UINT64_C(0xffff9669ffffffff), 0 }, +}; + +static dstatement_t ulong_hop_statements[] = { + { OP(0, 0, 0, OP_WITH), 0, 8, 1 }, + { OP(0, 0, 0, OP_WITH), 0, 24, 2 }, + { OP(0, 0, 0, OP_WITH), 0, 40, 3 }, + + { OP(0, 0, 1, OP_HOPS), 4, 050, 0 }, + { OP(0, 0, 1, OP_HOPS), 4, 051, 2 }, + { OP(0, 0, 1, OP_HOPS), 4, 052, 4 }, + { OP(0, 0, 1, OP_HOPS), 4, 053, 6 }, + { OP(0, 0, 1, OP_HOPS), 4, 054, 8 }, + { OP(0, 0, 1, OP_HOPS), 4, 055, 10 }, + { OP(0, 0, 1, OP_HOPS), 4, 056, 12 }, + + { OP(0, 0, 2, OP_HOPS), 2, 060, 0 }, + { OP(0, 0, 2, OP_HOPS), 2, 061, 2 }, + { OP(0, 0, 2, OP_HOPS), 2, 062, 4 }, + { OP(0, 0, 2, OP_HOPS), 2, 063, 6 }, + { OP(0, 0, 2, OP_HOPS), 2, 064, 8 }, + { OP(0, 0, 2, OP_HOPS), 2, 065, 10 }, + { OP(0, 0, 2, OP_HOPS), 2, 066, 12 }, + + { OP(0, 0, 3, OP_HOPS), 0, 070, 0 }, + { OP(0, 0, 3, OP_HOPS), 0, 071, 2 }, + { OP(0, 0, 3, OP_HOPS), 0, 072, 4 }, + { OP(0, 0, 3, OP_HOPS), 0, 073, 6 }, + { OP(0, 0, 3, OP_HOPS), 0, 074, 8 }, + { OP(0, 0, 3, OP_HOPS), 0, 075, 10 }, + { OP(0, 0, 3, OP_HOPS), 0, 076, 12 }, +}; + +static pr_vec4_t float_hop_init[2] = { + { 1, 2, 3, 4 }, +}; + +static pr_vec4_t float_hop_expect[] = { + { 1, 2, 3, 4 }, + { 3, 6, 10, 0 }, +}; + +static dstatement_t float_hop_statements[] = { + { OP(0, 0, 0, OP_HOPS), 0, 017, 4 }, + { OP(0, 0, 0, OP_HOPS), 0, 027, 5 }, + { OP(0, 0, 0, OP_HOPS), 0, 037, 6 }, +}; + +static pr_dvec4_t double_hop_init[2] = { + { 1, 2, 3, 4 }, +}; + +static pr_dvec4_t double_hop_expect[] = { + { 1, 2, 3, 4 }, + { 3, 6, 10, 0 }, +}; + +static dstatement_t double_hop_statements[] = { + { OP(0, 0, 0, OP_HOPS), 0, 057, 8 }, + { OP(0, 0, 0, OP_HOPS), 0, 067, 10 }, + { OP(0, 0, 0, OP_HOPS), 0, 077, 12 }, +}; + +test_t tests[] = { + { + .desc = "uint hops", + .num_globals = num_globals(uint_hop_init,uint_hop_expect), + .num_statements = num_statements (uint_hop_statements), + .statements = uint_hop_statements, + .init_globals = (pr_int_t *) uint_hop_init, + .expect_globals = (pr_int_t *) uint_hop_expect, + }, + { + .desc = "ulong hops", + .num_globals = num_globals(ulong_hop_init,ulong_hop_expect), + .num_statements = num_statements (ulong_hop_statements), + .statements = ulong_hop_statements, + .init_globals = (pr_int_t *) ulong_hop_init, + .expect_globals = (pr_int_t *) ulong_hop_expect, + }, + { + .desc = "float hops", + .num_globals = num_globals(float_hop_init,float_hop_expect), + .num_statements = num_statements (float_hop_statements), + .statements = float_hop_statements, + .init_globals = (pr_int_t *) float_hop_init, + .expect_globals = (pr_int_t *) float_hop_expect, + }, + { + .desc = "double hops", + .num_globals = num_globals(double_hop_init,double_hop_expect), + .num_statements = num_statements (double_hop_statements), + .statements = double_hop_statements, + .init_globals = (pr_int_t *) double_hop_init, + .expect_globals = (pr_int_t *) double_hop_expect, + }, +}; + +#include "main.c" From 2b8253352699e0bc6b26423f4295b021b7c2b6bf Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 16 Jan 2022 19:32:47 +0900 Subject: [PATCH 117/360] [gamecode] Add double time state instructions This has been a long-held wishlist item, really, and I thought I might as well take the opportunity to add the instructions. The double versions of STATE require both the nextthink field and time global to be double (but they're not resolved properly yet: marked with "FIXME double time" comments). Also, the frame number for double time state is integer rather than float. --- include/QF/progs.h | 3 +- libs/console/menu.c | 6 ++-- libs/gamecode/opcodes.py | 36 +++++++++++++------ libs/gamecode/pr_edict.c | 10 +++--- libs/gamecode/pr_exec.c | 67 ++++++++++++++++++++++++----------- libs/gamecode/pr_resolve.c | 4 +-- libs/gamecode/pr_v6p_opcode.c | 2 +- nq/source/sv_progs.c | 2 +- qw/source/sv_progs.c | 2 +- 9 files changed, 87 insertions(+), 45 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 572528891..798806de5 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1962,7 +1962,8 @@ struct progs_s { /// \name globals and fields needed by the VM ///@{ struct { - float *time; ///< required for OP_STATE + double *dtime; ///< required for OP_STATE d + float *ftime; ///< required for OP_STATE f pr_int_t *self; ///< required for OP_STATE pointer_t *stack; ///< required for OP_(PUSH|POP)* } globals; diff --git a/libs/console/menu.c b/libs/console/menu.c index e6dcc72a4..a98c2d71a 100644 --- a/libs/console/menu.c +++ b/libs/console/menu.c @@ -134,7 +134,7 @@ menu_resolve_globals (progs_t *pr) if (!(def = PR_FindGlobal (pr, sym = "time"))) goto error; - menu_pr_state.globals.time = &G_FLOAT (pr, def->ofs); + menu_pr_state.globals.ftime = &G_FLOAT (pr, def->ofs);//FIXME double time return 1; error: Sys_Printf ("%s: undefined symbol %s\n", pr->progs_name, sym); @@ -672,7 +672,7 @@ Menu_Draw (view_t *view) if (menu->fadescreen) r_funcs->Draw_FadeScreen (); - *menu_pr_state.globals.time = *con_data.realtime; + *menu_pr_state.globals.ftime = *con_data.realtime;//FIXME double time if (menu->draw) { int ret; @@ -729,7 +729,7 @@ void Menu_Draw_Hud (view_t *view) { run_menu_pre (); - *menu_pr_state.globals.time = *con_data.realtime; + *menu_pr_state.globals.ftime = *con_data.realtime;//FIXME double time PR_ExecuteProgram (&menu_pr_state, menu_draw_hud); run_menu_post (); diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index db39a5621..4b123ce19 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -19,14 +19,16 @@ bitmap_txt = """ 1 1010 t100 swizzle 1 1011 tooo vecops 1 1101 01oo move -1 1101 0111 convert (conversion mode in st->b) 1 1101 11oo memset -1 1101 1111 with (mode in st->a, value in st->b, reg in st->c) +1 1101 c111 statef 1 1110 c1cc branch -1 1110 t111 state +1 1110 c111 stated 1 1111 00mm lea 1 1111 01td vecops2 -1 1111 1nnn +1 1111 10nn +1 1111 1100 convert (conversion mode in st->b) +1 1111 1101 with (mode in st->a, value in st->b, reg in st->c) +1 1111 1110 1 1111 1111 hops """ @@ -328,19 +330,32 @@ shiftops_formats = { ], }, } -state_formats = { - "opcode": "OP_STATE_{state[t]}", - "mnemonic": "state.{state[t]}", +statef_formats = { + "opcode": "OP_STATE_{state[c]}", + "mnemonic": "state.{state[c]}", "opname": "state", - "format": "{state_fmt[t]}", + "format": "{state_fmt[c]}", "widths": "1, 1, 1", - "types": "ev_float, ev_func, {state_types[t]}", + "types": "ev_float, ev_func, {state_types[c]}", "args": { "state": ["ft", "ftt"], "state_fmt": ["%Ga, %Gb", "%Ga, %Gb, %Gc"], "state_types": ["ev_invalid", "ev_float"], }, } +stated_formats = { + "opcode": "OP_STATE_{state[c]}", + "mnemonic": "state.{state[c]}", + "opname": "state", + "format": "{state_fmt[c]}", + "widths": "1, 1, 1", + "types": "ev_float, ev_func, {state_types[c]}", + "args": { + "state": ["dt", "dtt"], + "state_fmt": ["%Ga, %Gb", "%Ga, %Gb, %Gc"], + "state_types": ["ev_invalid", "ev_double"], + }, +} store_formats = { "opcode": "OP_STORE_{op_mode[mm]}_{ss+1}", "mnemonic": "store", @@ -476,7 +491,8 @@ group_map = { "popregs": popregs_formats, "scale": scale_formats, "shiftops": shiftops_formats, - "state": state_formats, + "statef": statef_formats, + "stated": stated_formats, "store": store_formats, "string": string_formats, "swizzle": swizzle_formats, diff --git a/libs/gamecode/pr_edict.c b/libs/gamecode/pr_edict.c index f16c2bd41..c766c0861 100644 --- a/libs/gamecode/pr_edict.c +++ b/libs/gamecode/pr_edict.c @@ -79,9 +79,9 @@ ED_Alloc (progs_t *pr) e = EDICT_NUM (pr, i); // the first couple seconds of server time can involve a lot of // freeing and allocating, so relax the replacement policy - if (e->free && (!pr->globals.time + if (e->free && (!pr->globals.ftime//FIXME double time || e->freetime < 2 - || *pr->globals.time - e->freetime > 0.5)) { + || *pr->globals.ftime - e->freetime > 0.5)) { ED_ClearEdict (pr, e, 0); return e; } @@ -123,8 +123,8 @@ ED_Free (progs_t *pr, edict_t *ed) ED_ClearEdict (pr, ed, 0); } ed->free = true; - if (pr->globals.time) - ed->freetime = *pr->globals.time; + if (pr->globals.ftime)//FIXME double time + ed->freetime = *pr->globals.ftime; } //=========================================================================== @@ -199,7 +199,7 @@ ED_Count (progs_t *pr) for (i = 0; i < *pr->num_edicts; i++) { ent = EDICT_NUM (pr, i); if (ent->free) { - if (pr->globals.time && *pr->globals.time - ent->freetime <= 0.5) + if (pr->globals.ftime && *pr->globals.ftime - ent->freetime <= 0.5)//FIXME double time zombie++; continue; } diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 8a0429807..adf9cf515 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1482,7 +1482,7 @@ op_call: int nextthink = pr->fields.nextthink + self; int frame = pr->fields.frame + self; int think = pr->fields.think + self; - float time = *pr->globals.time + 0.1; + float time = *pr->globals.ftime + 0.1; pr->pr_edict_area[nextthink].float_var = time; pr->pr_edict_area[frame].float_var = OPA(float); pr->pr_edict_area[think].func_var = OPB(uint); @@ -1494,7 +1494,7 @@ op_call: int nextthink = pr->fields.nextthink + self; int frame = pr->fields.frame + self; int think = pr->fields.think + self; - float time = *pr->globals.time + OPC(float); + float time = *pr->globals.ftime + OPC(float); pr->pr_edict_area[nextthink].float_var = time; pr->pr_edict_area[frame].float_var = OPA(float); pr->pr_edict_area[think].func_var = OPB(uint); @@ -2891,9 +2891,13 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) MM(ivec4) = STK(ivec4); break; // 0 0100 + // spare // 0 0101 + // spare // 0 0110 + // spare // 0 0111 + // spare #define OP_cmp_1(OP, T, rt, cmp, ct) \ case OP_##OP##_##T##_1: \ @@ -2936,7 +2940,6 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OP_cmp(GE, >=); // 0 1110 OP_cmp(LE, <=); - // 0 1111 // spare @@ -3276,12 +3279,16 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) memmove (pr->pr_globals + OPC(int), pr->pr_globals + OPA(int), st->b * sizeof (pr_type_t)); break; - case OP_CONV: - switch (st->b) { -#include "libs/gamecode/pr_convert.cinc" - default: - PR_RunError (pr, "invalid conversion code: %04o", - st->b); + case OP_STATE_ft: + { + int self = *pr->globals.self; + int nextthink = pr->fields.nextthink + self; + int frame = pr->fields.frame + self; + int think = pr->fields.think + self; + float time = *pr->globals.ftime + 0.1; + pr->pr_edict_area[nextthink].float_var = time; + pr->pr_edict_area[frame].float_var = OPA(float); + pr->pr_edict_area[think].func_var = op_b->func_var; } break; OP_cmp_T (GE, U, long, lvec2, lvec4, >=, ulong, ulvec2, ulvec4); @@ -3294,8 +3301,17 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_MEMSET_PI: pr_memset (pr->pr_globals + OPC(int), OPA(int), st->b); break; - case OP_WITH: - pr_with (pr, st); + case OP_STATE_ftt: + { + int self = *pr->globals.self; + int nextthink = pr->fields.nextthink + self; + int frame = pr->fields.frame + self; + int think = pr->fields.think + self; + float time = *pr->globals.ftime + OPC(float); + pr->pr_edict_area[nextthink].float_var = time; + pr->pr_edict_area[frame].float_var = OPA(float); + pr->pr_edict_area[think].func_var = op_b->func_var; + } break; // 1 1110 OP_cmp_T (LE, u, int, ivec2, ivec4, <=, uint, uivec2, uivec4); @@ -3317,15 +3333,15 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) st = pr->pr_statements + pr->pr_xstatement; } break; - case OP_STATE_ft: + case OP_STATE_dt: { int self = *pr->globals.self; int nextthink = pr->fields.nextthink + self; int frame = pr->fields.frame + self; int think = pr->fields.think + self; - float time = *pr->globals.time + 0.1; - pr->pr_edict_area[nextthink].float_var = time; - pr->pr_edict_area[frame].float_var = OPA(float); + double time = *pr->globals.dtime + 0.1; + *(double *) (&pr->pr_edict_area[nextthink]) = time; + pr->pr_edict_area[frame].integer_var = OPA(int); pr->pr_edict_area[think].func_var = op_b->func_var; } break; @@ -3348,15 +3364,15 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) st = pr->pr_statements + pr->pr_xstatement; } break; - case OP_STATE_ftt: + case OP_STATE_dtt: { int self = *pr->globals.self; int nextthink = pr->fields.nextthink + self; int frame = pr->fields.frame + self; int think = pr->fields.think + self; - float time = *pr->globals.time + OPC(float); - pr->pr_edict_area[nextthink].float_var = time; - pr->pr_edict_area[frame].float_var = OPA(float); + double time = *pr->globals.dtime + OPC(double); + *(double *) (&pr->pr_edict_area[nextthink]) = time; + pr->pr_edict_area[frame].integer_var = OPA(int); pr->pr_edict_area[think].func_var = op_b->func_var; } break; @@ -3384,8 +3400,17 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OPC(dvec4) = vqmuld (OPA(dvec4), OPB(dvec4)); break; // 10nn spare - // 1100 spare - // 1101 spare + case OP_CONV: + switch (st->b) { +#include "libs/gamecode/pr_convert.cinc" + default: + PR_RunError (pr, "invalid conversion code: %04o", + st->b); + } + break; + case OP_WITH: + pr_with (pr, st); + break; // 1110 spare #define OP_hop2(vec, op) ((vec)[0] op (vec)[1]) #define OP_hop3(vec, op) ((vec)[0] op (vec)[1] op (vec)[2]) diff --git a/libs/gamecode/pr_resolve.c b/libs/gamecode/pr_resolve.c index 6270653d2..c62a8e9cb 100644 --- a/libs/gamecode/pr_resolve.c +++ b/libs/gamecode/pr_resolve.c @@ -143,9 +143,9 @@ PR_ResolveGlobals (progs_t *pr) pr->pr_param_alignment = G_INT (pr, def->ofs); } memcpy (pr->pr_real_params, pr->pr_params, sizeof (pr->pr_params)); - if (!pr->globals.time) { + if (!pr->globals.ftime) {//FIXME double time if ((def = PR_FindGlobal (pr, "time"))) - pr->globals.time = &G_FLOAT (pr, def->ofs); + pr->globals.ftime = &G_FLOAT (pr, def->ofs); } if (!pr->globals.self) { if ((def = PR_FindGlobal (pr, ".self")) diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index 5ded2c764..6163050eb 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -1637,7 +1637,7 @@ PR_Check_Opcodes (progs_t *pr) int pushpop_ok = 0; pr_uint_t i; - if (pr->globals.time && pr->globals.self && pr->fields.nextthink != -1 + if (pr->globals.ftime && pr->globals.self && pr->fields.nextthink != -1 && pr->fields.think != -1 && pr->fields.frame != -1) { state_ok = 1; } diff --git a/nq/source/sv_progs.c b/nq/source/sv_progs.c index 2c9d82836..3a8c44dd2 100644 --- a/nq/source/sv_progs.c +++ b/nq/source/sv_progs.c @@ -460,7 +460,7 @@ resolve (progs_t *pr) resolve_fields (pr, nq_opt_fields, 0); // progs engine needs these globals anyway sv_pr_state.globals.self = sv_globals.self; - sv_pr_state.globals.time = sv_globals.time; + sv_pr_state.globals.ftime = sv_globals.time;//FIXME double time return ret; } diff --git a/qw/source/sv_progs.c b/qw/source/sv_progs.c index 93f6042a0..6351317e8 100644 --- a/qw/source/sv_progs.c +++ b/qw/source/sv_progs.c @@ -493,7 +493,7 @@ resolve (progs_t *pr) resolve_fields (pr, qw_opt_fields, 0); // progs engine needs these globals anyway sv_pr_state.globals.self = sv_globals.self; - sv_pr_state.globals.time = sv_globals.time; + sv_pr_state.globals.ftime = sv_globals.time;//FIXME double time return ret; } From 0bd05c71ac7e68b9982ffe373c87c3cc1b3038cf Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 16 Jan 2022 22:15:18 +0900 Subject: [PATCH 118/360] [gamecode] Use unsigned for entity values I don't know why they were ever signed (oversight at id and just propagated?). Anyway, this resulted in "unsigned" spreading a bit, but all to reasonable places. --- include/QF/progs.h | 16 ++++++++-------- include/QF/progs/pr_comp.h | 2 +- include/netmain.h | 2 +- libs/gamecode/pr_debug.c | 2 +- libs/gamecode/pr_edict.c | 17 ++++++++--------- libs/gamecode/pr_resolve.c | 2 +- libs/net/net_main.c | 6 +++--- libs/net/nm/net_dgrm.c | 2 +- libs/ruamoko/pr_cmds.c | 4 ++-- nq/include/server.h | 6 +++--- nq/include/sv_progs.h | 12 ++++++------ nq/source/host.c | 15 ++++++++------- nq/source/host_cmd.c | 27 +++++++++++++-------------- nq/source/sv_main.c | 20 ++++++++++---------- nq/source/sv_phys.c | 8 ++++---- nq/source/sv_pr_cmds.c | 27 ++++++++++++++------------- nq/source/sv_user.c | 2 +- nq/source/world.c | 8 +++----- qw/include/server.h | 6 +++--- qw/include/sv_progs.h | 12 ++++++------ qw/source/sv_init.c | 7 ++----- qw/source/sv_phys.c | 8 ++++---- qw/source/sv_pr_cmds.c | 7 +++---- qw/source/sv_progs.c | 2 +- qw/source/sv_user.c | 9 +++------ qw/source/world.c | 8 +++----- tools/qfcc/source/qfprogs.c | 4 ++-- tools/qfcc/test/test-harness.c | 4 ++-- 28 files changed, 117 insertions(+), 128 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 798806de5..e8b4136dc 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -276,8 +276,8 @@ void PR_BoundsCheck (progs_t *pr, int addr, etype_t type); struct edict_s { qboolean free; progs_t *pr; ///< progs owning this edict - int entnum; ///< number of this entity - int edict; ///< offset of this entity in pr_edict_area + pr_uint_t entnum; ///< number of this entity + pr_uint_t edict; ///< offset of this entity in pr_edict_area float freetime; ///< sv.time when the object was freed void *edata; ///< external per-edict data }; @@ -286,8 +286,8 @@ struct edict_s { void ED_ClearEdict (progs_t *pr, edict_t *e, int val); edict_t *ED_Alloc (progs_t *pr); void ED_Free (progs_t *pr, edict_t *ed); -edict_t *ED_EdictNum(progs_t *pr, pr_int_t n) __attribute__((pure)); -pr_int_t ED_NumForEdict(progs_t *pr, edict_t *e) __attribute__((pure)); +edict_t *ED_EdictNum(progs_t *pr, pr_uint_t n) __attribute__((pure)); +pr_uint_t ED_NumForEdict(progs_t *pr, edict_t *e) __attribute__((pure)); void ED_Count (progs_t *pr); qboolean PR_EdictValid (progs_t *pr, pr_uint_t e) __attribute__((pure)); @@ -1896,9 +1896,9 @@ struct progs_s { /// \todo FIXME should this be outside the VM? ///@{ edict_t **pr_edicts; - int max_edicts; ///< set by user - int *num_edicts; - int *reserved_edicts; ///< alloc will start at reserved_edicts+1 + pr_uint_t max_edicts; ///< set by user + pr_uint_t *num_edicts; + pr_uint_t *reserved_edicts; ///< alloc will start at reserved_edicts+1 void (*unlink) (edict_t *ent); void (*flush) (void); int (*prune_edict) (progs_t *pr, edict_t *ent); @@ -1964,7 +1964,7 @@ struct progs_s { struct { double *dtime; ///< required for OP_STATE d float *ftime; ///< required for OP_STATE f - pr_int_t *self; ///< required for OP_STATE + pr_uint_t *self; ///< required for OP_STATE pointer_t *stack; ///< required for OP_(PUSH|POP)* } globals; struct { diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 8ce204613..2b5c0ad79 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -537,7 +537,7 @@ typedef union pr_type_u { float float_var; string_t string_var; func_t func_var; - pr_int_t entity_var; + pr_uint_t entity_var; float vector_var; // really [3], but this structure must be 32 bits float quat_var; // really [4], but this structure must be 32 bits pr_int_t integer_var; diff --git a/include/netmain.h b/include/netmain.h index 43b947aa7..0a4587b26 100644 --- a/include/netmain.h +++ b/include/netmain.h @@ -268,7 +268,7 @@ void NET_AddCachedHost (const char *name, const char *map, const char *cname, extern double net_time; extern struct msg_s *net_message; -extern int net_activeconnections; +extern unsigned net_activeconnections; /** Initialize the networking sub-system. */ diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index b77dc940a..1034c7b95 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -1266,7 +1266,7 @@ pr_debug_entity_view (qfot_type_t *type, pr_type_t *value, void *_data) progs_t *pr = data->pr; dstring_t *dstr = data->dstr; - if (pr->pr_edicts && value->entity_var >= 0 + if (pr->pr_edicts && value->entity_var < pr->max_edicts && !(value->entity_var % pr->pr_edict_size)) { edict_t *edict = PROG_TO_EDICT (pr, value->entity_var); diff --git a/libs/gamecode/pr_edict.c b/libs/gamecode/pr_edict.c index c766c0861..34c132b20 100644 --- a/libs/gamecode/pr_edict.c +++ b/libs/gamecode/pr_edict.c @@ -68,7 +68,7 @@ ED_ClearEdict (progs_t *pr, edict_t *e, int val) VISIBLE edict_t * ED_Alloc (progs_t *pr) { - pr_int_t i; + pr_uint_t i; edict_t *e; int start = pr->reserved_edicts ? *pr->reserved_edicts : 0; @@ -149,7 +149,7 @@ ED_PrintNum (progs_t *pr, pr_int_t ent, const char *fieldname) VISIBLE void ED_PrintEdicts (progs_t *pr, const char *fieldval) { - pr_int_t i; + pr_uint_t i; int count; pr_def_t *def; @@ -183,7 +183,6 @@ ED_PrintEdicts (progs_t *pr, const char *fieldval) VISIBLE void ED_Count (progs_t *pr) { - pr_int_t i; int active, models, solid, step, zombie; pr_def_t *solid_def; pr_def_t *model_def; @@ -196,7 +195,7 @@ ED_Count (progs_t *pr) solid_def = PR_FindField (pr, "solid"); model_def = PR_FindField (pr, "model"); active = models = solid = step = zombie = 0; - for (i = 0; i < *pr->num_edicts; i++) { + for (pr_uint_t i = 0; i < *pr->num_edicts; i++) { ent = EDICT_NUM (pr, i); if (ent->free) { if (pr->globals.ftime && *pr->globals.ftime - ent->freetime <= 0.5)//FIXME double time @@ -218,22 +217,22 @@ ED_Count (progs_t *pr) } edict_t * -ED_EdictNum (progs_t *pr, pr_int_t n) +ED_EdictNum (progs_t *pr, pr_uint_t n) { - if (n < 0 || n >= *pr->num_edicts) + if (n >= *pr->num_edicts) PR_RunError (pr, "EDICT_NUM: bad number %d", n); return PR_edicts(pr) + n; } -pr_int_t +pr_uint_t ED_NumForEdict (progs_t *pr, edict_t *e) { - pr_int_t b; + pr_uint_t b; b = NUM_FOR_BAD_EDICT (pr, e); - if (b && (b < 0 || b >= *pr->num_edicts)) + if (b && b >= *pr->num_edicts) PR_RunError (pr, "NUM_FOR_EDICT: bad pointer %d %p %p", b, e, pr->pr_edicts); diff --git a/libs/gamecode/pr_resolve.c b/libs/gamecode/pr_resolve.c index c62a8e9cb..c0c090016 100644 --- a/libs/gamecode/pr_resolve.c +++ b/libs/gamecode/pr_resolve.c @@ -150,7 +150,7 @@ PR_ResolveGlobals (progs_t *pr) if (!pr->globals.self) { if ((def = PR_FindGlobal (pr, ".self")) || (def = PR_FindGlobal (pr, "self"))) - pr->globals.self = &G_INT (pr, def->ofs); + pr->globals.self = &G_UINT (pr, def->ofs); } if (!pr->globals.stack) { if ((def = PR_FindGlobal (pr, ".stack")) diff --git a/libs/net/net_main.c b/libs/net/net_main.c index 9d8a34e09..e534c4156 100644 --- a/libs/net/net_main.c +++ b/libs/net/net_main.c @@ -78,7 +78,7 @@ PollProcedure slistPollProcedure = { NULL, 0.0, Slist_Poll }; static sizebuf_t _net_message_message; static qmsg_t _net_message = { 0, 0, &_net_message_message }; qmsg_t *net_message = &_net_message; -int net_activeconnections = 0; +unsigned net_activeconnections = 0; int messagesSent = 0; int messagesReceived = 0; @@ -197,7 +197,7 @@ NET_Listen_f (void) static void MaxPlayers_f (void) { - int n; + unsigned n; if (Cmd_Argc () != 2) { Sys_Printf ("\"maxplayers\" is \"%u\"\n", svs.maxclients); @@ -710,7 +710,7 @@ int NET_SendToAll (sizebuf_t *data, double blocktime) { double start; - int i; + unsigned i; int count = 0; qboolean state1[MAX_SCOREBOARD]; /* can we send */ qboolean state2[MAX_SCOREBOARD]; /* did we send */ diff --git a/libs/net/nm/net_dgrm.c b/libs/net/nm/net_dgrm.c index 3f9cf50b1..9aa10ef31 100644 --- a/libs/net/nm/net_dgrm.c +++ b/libs/net/nm/net_dgrm.c @@ -652,7 +652,7 @@ _Datagram_CheckNewConnections (void) if (command == CCREQ_PLAYER_INFO) { int playerNumber; int activeNumber; - int clientNumber; + unsigned clientNumber; client_t *client; playerNumber = MSG_ReadByte (net_message); diff --git a/libs/ruamoko/pr_cmds.c b/libs/ruamoko/pr_cmds.c index cc7a7d8b9..36827ad4e 100644 --- a/libs/ruamoko/pr_cmds.c +++ b/libs/ruamoko/pr_cmds.c @@ -253,7 +253,7 @@ PF_Find (progs_t *pr) { const char *s = 0, *t; // ev_string int i; // ev_vector - int e, f; + pr_uint_t e, f; etype_t type; pr_def_t *field_def; edict_t *ed; @@ -394,7 +394,7 @@ PF_ceil (progs_t *pr) static void PF_nextent (progs_t *pr) { - int i; + pr_uint_t i; edict_t *ent; i = P_EDICTNUM (pr, 0); diff --git a/nq/include/server.h b/nq/include/server.h index 7e78394ce..5af088cc8 100644 --- a/nq/include/server.h +++ b/nq/include/server.h @@ -44,8 +44,8 @@ extern progs_t sv_pr_state; typedef struct { - int maxclients; - int maxclientslimit; + unsigned maxclients; + unsigned maxclientslimit; struct client_s *clients; // [maxclients] void (*phys_client) (struct edict_s *ent, int num); int serverflags; // episode completion information @@ -75,7 +75,7 @@ typedef struct struct model_s *models[MAX_MODELS]; const char *sound_precache[MAX_SOUNDS]; // NULL terminated const char *lightstyles[MAX_LIGHTSTYLES]; - int num_edicts; + unsigned num_edicts; int max_edicts; edict_t *edicts; // can NOT be array indexed, because // edict_t is variable sized, but can diff --git a/nq/include/sv_progs.h b/nq/include/sv_progs.h index 71a371f48..0d0ea9635 100644 --- a/nq/include/sv_progs.h +++ b/nq/include/sv_progs.h @@ -38,9 +38,9 @@ #include "sv_pr_cmds.h" typedef struct { - pr_int_t *self; - pr_int_t *other; - pr_int_t *world; + pr_uint_t *self; + pr_uint_t *other; + pr_uint_t *world; float *time; float *frametime; float *force_retouch; @@ -64,13 +64,13 @@ typedef struct { vec3_t *trace_endpos; vec3_t *trace_plane_normal; float *trace_plane_dist; - pr_int_t *trace_ent; + pr_uint_t *trace_ent; float *trace_inopen; float *trace_inwater; - pr_int_t *msg_entity; + pr_uint_t *msg_entity; string_t *null; - pr_int_t *newmis; + pr_uint_t *newmis; } sv_globals_t; extern sv_globals_t sv_globals; diff --git a/nq/source/host.c b/nq/source/host.c index be2b2d232..907250a5c 100644 --- a/nq/source/host.c +++ b/nq/source/host.c @@ -323,7 +323,6 @@ void SV_BroadcastPrintf (const char *fmt, ...) { static dstring_t *str; - int i; va_list argptr; if (!str) @@ -333,7 +332,7 @@ SV_BroadcastPrintf (const char *fmt, ...) dvsprintf (str, fmt, argptr); va_end (argptr); - for (i = 0; i < svs.maxclients; i++) + for (unsigned i = 0; i < svs.maxclients; i++) if (svs.clients[i].active && svs.clients[i].spawned) { MSG_WriteByte (&svs.clients[i].message, svc_print); MSG_WriteString (&svs.clients[i].message, str->str); @@ -372,7 +371,8 @@ void SV_DropClient (qboolean crash) { client_t *client; - int saveSelf, i; + unsigned i; + pr_uint_t saveSelf; if (!crash) { // send any final messages (don't check for errors) @@ -406,7 +406,8 @@ SV_DropClient (qboolean crash) net_activeconnections--; // send notification to all clients - for (i = 0, client = svs.clients; i < svs.maxclients; i++, client++) { + for (i = 0, client = svs.clients; i < svs.maxclients; + i++, client++) { if (!client->active) continue; MSG_WriteByte (&client->message, svc_updatename); @@ -431,7 +432,7 @@ Host_ShutdownServer (qboolean crash) { byte message[4]; double start; - int count, i; + unsigned count, i; sizebuf_t buf; if (!sv.active) @@ -711,7 +712,7 @@ Host_Frame (float time) { double time1, time2; static double timetotal; - int i, c, m; + int c, m; static int timecount; if (!serverprofile->int_val) { @@ -733,7 +734,7 @@ Host_Frame (float time) timecount = 0; timetotal = 0; c = 0; - for (i = 0; i < svs.maxclients; i++) { + for (unsigned i = 0; i < svs.maxclients; i++) { if (svs.clients[i].active) c++; } diff --git a/nq/source/host_cmd.c b/nq/source/host_cmd.c index 9f10ed8e9..3c51cb894 100644 --- a/nq/source/host_cmd.c +++ b/nq/source/host_cmd.c @@ -78,7 +78,7 @@ Host_Status_f (void) int seconds; int minutes; int hours = 0; - int j; + unsigned j; __attribute__((format(PRINTF, 1, 2))) void (*print) (const char *fmt, ...); if (cmd_source == src_command) { @@ -210,7 +210,7 @@ Host_Fly_f (void) static void Host_Ping_f (void) { - int i, j; + unsigned i, j; float total; client_t *client; @@ -421,7 +421,7 @@ static plitem_t * entities_array (void) { plitem_t *entities = PL_NewArray (); - int i; + pr_uint_t i; for (i = 0; i < sv.num_edicts; i++) { PL_A_AddObject (entities, @@ -517,7 +517,6 @@ Host_Savegame_f (void) const char *save_name; char *save_text; QFile *f; - int i; char *bup1, *bup2 = 0; @@ -549,7 +548,7 @@ Host_Savegame_f (void) return; } - for (i = 0; i < svs.maxclients; i++) { + for (unsigned i = 0; i < svs.maxclients; i++) { if (svs.clients[i].active && (SVfloat (svs.clients[i].edict, health) <= 0)) { Sys_Printf ("Can't savegame with a dead player\n"); @@ -562,7 +561,7 @@ Host_Savegame_f (void) if (strcmp (save_name, "quick") == 0) { bup2 = nva ("%s/%s%d.sav", qfs_gamedir->dir.def, save_name, MAX_QUICK); QFS_Remove (bup2); - for (i = MAX_QUICK - 1; i > 0; i--) { + for (int i = MAX_QUICK - 1; i > 0; i--) { bup1 = nva ("%s/%s%d.sav", qfs_gamedir->dir.def, save_name, i); QFS_Rename (bup1, bup2); free (bup2); @@ -783,7 +782,7 @@ Host_Say (qboolean teamonly) { client_t *client; client_t *save; - int j; + unsigned j; char *p; char text[64]; qboolean fromServer = false; @@ -817,7 +816,7 @@ Host_Say (qboolean teamonly) snprintf (text, sizeof (text), "%c<%s> ", 1, hostname->string); j = sizeof (text) - 2 - strlen (text); // -2 for /n and null terminator - if ((int) strlen (p) > j) + if (strlen (p) > j) p[j] = 0; strcat (text, p); @@ -854,7 +853,7 @@ Host_Tell_f (void) { client_t *client; client_t *save; - int j; + unsigned j; char *p; char text[64]; @@ -879,7 +878,7 @@ Host_Tell_f (void) } // check length & truncate if necessary j = sizeof (text) - 2 - strlen (text); // -2 for /n and null terminator - if ((int) strlen (p) > j) + if (strlen (p) > j) p[j] = 0; strcat (text, p); @@ -969,7 +968,7 @@ Host_PreSpawn_f (void) static void Host_Spawn_f (void) { - int i; + unsigned i; client_t *client; edict_t *ent; float *sendangles; @@ -1099,7 +1098,7 @@ Host_Kick_f (void) const char *who; const char *message = NULL; client_t *save; - int i; + unsigned i; qboolean byNumber = false; if (cmd_source == src_command) { @@ -1115,7 +1114,7 @@ Host_Kick_f (void) if (Cmd_Argc () > 2 && strcmp (Cmd_Argv (1), "#") == 0) { i = atof (Cmd_Argv (2)) - 1; - if (i < 0 || i >= svs.maxclients) + if (i >= svs.maxclients) return; if (!svs.clients[i].active) return; @@ -1291,7 +1290,7 @@ Host_Give_f (void) static edict_t * FindViewthing (void) { - int i; + pr_uint_t i; edict_t *e; for (i = 0; i < sv.num_edicts; i++) { diff --git a/nq/source/sv_main.c b/nq/source/sv_main.c index 3f5e248e2..f11f1389d 100644 --- a/nq/source/sv_main.c +++ b/nq/source/sv_main.c @@ -351,7 +351,7 @@ SV_ConnectClient (int clientnum) void SV_CheckForNewClients (void) { - int i; + unsigned i; struct qsocket_s *ret; // check for new connections @@ -443,7 +443,7 @@ SV_FatPVS (vec3_t org) static void SV_WriteEntitiesToClient (edict_t *clent, sizebuf_t *msg) { - int bits, e, i; + pr_uint_t bits, e; set_t *pvs; float miss; vec3_t org; @@ -489,7 +489,7 @@ SV_WriteEntitiesToClient (edict_t *clent, sizebuf_t *msg) bits = 0; - for (i = 0; i < 3; i++) { + for (int i = 0; i < 3; i++) { miss = SVvector (ent, origin)[i] - baseline->origin[i]; if (miss < -0.1 || miss > 0.1) bits |= U_ORIGIN1 << i; @@ -603,7 +603,7 @@ SV_WriteEntitiesToClient (edict_t *clent, sizebuf_t *msg) static void SV_CleanupEnts (void) { - int e; + pr_uint_t e; edict_t *ent; ent = NEXT_EDICT (&sv_pr_state, sv.edicts); @@ -826,7 +826,7 @@ SV_SendClientDatagram (client_t *client) static void SV_UpdateToReliableMessages (void) { - int i, j; + unsigned i, j; client_t *client; // check for changes to be sent over the reliable streams @@ -884,7 +884,7 @@ SV_SendNop (client_t *client) void SV_SendClientMessages (void) { - int i; + unsigned i; // update frags, names, etc SV_UpdateToReliableMessages (); @@ -964,7 +964,7 @@ SV_ModelIndex (const char *name) static void SV_CreateBaseline (void) { - int entnum; + pr_uint_t entnum; edict_t *svent; entity_state_t *baseline; int bits; @@ -1077,7 +1077,7 @@ SV_SendReconnect (void) void SV_SaveSpawnparms (void) { - int i, j; + unsigned i, j; svs.serverflags = *sv_globals.serverflags; @@ -1161,7 +1161,7 @@ SV_SpawnServer (const char *server) // leave slots at start for only clients sv.num_edicts = svs.maxclients + 1; - for (int i = 0; i < svs.maxclients; i++) { + for (unsigned i = 0; i < svs.maxclients; i++) { ent = EDICT_NUM (&sv_pr_state, i + 1); svs.clients[i].edict = ent; } @@ -1243,7 +1243,7 @@ SV_SpawnServer (const char *server) sv.signon.cursize); // send serverinfo to all connected clients - for (int i = 0; i < svs.maxclients; i++) { + for (unsigned i = 0; i < svs.maxclients; i++) { host_client = svs.clients + i; if (host_client->active) { SV_SendServerinfo (host_client); diff --git a/nq/source/sv_phys.c b/nq/source/sv_phys.c index e017039a6..ab2b4f966 100644 --- a/nq/source/sv_phys.c +++ b/nq/source/sv_phys.c @@ -414,7 +414,7 @@ static qboolean SV_Push (edict_t *pusher, const vec3_t tmove, const vec3_t amove) { float solid_save; - int num_moved, i, e; + int num_moved, i; edict_t *check, *block; edict_t **moved_edict; vec3_t move, org, org2; @@ -455,7 +455,7 @@ SV_Push (edict_t *pusher, const vec3_t tmove, const vec3_t amove) // see if any solid entities are inside the final position num_moved = 0; check = NEXT_EDICT (&sv_pr_state, sv.edicts); - for (e = 1; e < sv.num_edicts; + for (unsigned e = 1; e < sv.num_edicts; e++, check = NEXT_EDICT (&sv_pr_state, check)) { if (check->free) continue; @@ -854,14 +854,14 @@ void SV_Physics (void) { edict_t *ent; - int i; SV_ProgStartFrame (); // treat each object in turn // even the world gets a chance to think ent = sv.edicts; - for (i = 0; i < sv.num_edicts; i++, ent = NEXT_EDICT (&sv_pr_state, ent)) { + for (unsigned i = 0; i < sv.num_edicts; + i++, ent = NEXT_EDICT (&sv_pr_state, ent)) { if (ent->free) continue; diff --git a/nq/source/sv_pr_cmds.c b/nq/source/sv_pr_cmds.c index 8f2262078..71a6d03f3 100644 --- a/nq/source/sv_pr_cmds.c +++ b/nq/source/sv_pr_cmds.c @@ -304,7 +304,7 @@ PF_sprint (progs_t *pr) { const char *s; client_t *client; - int entnum; + unsigned entnum; entnum = P_EDICTNUM (pr, 0); s = PF_VarString (pr, 1); @@ -333,7 +333,7 @@ PF_centerprint (progs_t *pr) { const char *s; client_t *cl; - int entnum; + unsigned entnum; entnum = P_EDICTNUM (pr, 0); s = PF_VarString (pr, 1); @@ -542,11 +542,11 @@ PF_checkpos (progs_t *pr) static set_t *checkpvs; -static int -PF_newcheckclient (progs_t *pr, int check) +static unsigned +PF_newcheckclient (progs_t *pr, unsigned check) { edict_t *ent; - int i; + unsigned i; mleaf_t *leaf; vec3_t org; @@ -656,7 +656,7 @@ PF_stuffcmd (progs_t *pr) { const char *str; client_t *old; - int entnum; + pr_uint_t entnum; entnum = P_EDICTNUM (pr, 0); if (entnum < 1 || entnum > svs.maxclients) @@ -700,7 +700,7 @@ PF_findradius (progs_t *pr) edict_t *ent, *chain; float rsqr; vec_t *emins, *emaxs, *org; - int i, j; + pr_uint_t i; vec3_t eorg; chain = (edict_t *) sv.edicts; @@ -717,7 +717,7 @@ PF_findradius (progs_t *pr) continue; emins = SVvector (ent, absmin); emaxs = SVvector (ent, absmax); - for (j = 0; j < 3; j++) + for (int j = 0; j < 3; j++) eorg[j] = org[j] - 0.5 * (emins[j] + emaxs[j]); if (DotProduct (eorg, eorg) > rsqr) continue; @@ -903,7 +903,8 @@ PF_lightstyle (progs_t *pr) { const char *val; client_t *cl; - int style, j; + int style; + unsigned j; style = P_FLOAT (pr, 0); val = P_GSTRING (pr, 1); @@ -960,7 +961,7 @@ PF_aim (progs_t *pr) edict_t *ent, *check, *bestent; float dist, bestdist, speed; float *mins, *maxs, *org; - int i, j; + pr_uint_t i; trace_t tr; vec3_t start, dir, end, bestdir; @@ -1000,7 +1001,7 @@ PF_aim (progs_t *pr) mins = SVvector (check, mins); maxs = SVvector (check, maxs); org = SVvector (check, origin); - for (j = 0; j < 3; j++) + for (int j = 0; j < 3; j++) end[j] = org[j] + 0.5 * (mins[j] + maxs[j]); VectorSubtract (end, start, dir); VectorNormalize (dir); @@ -1075,7 +1076,7 @@ PF_changeyaw (progs_t *pr) static __attribute__((pure)) sizebuf_t * WriteDest (progs_t *pr) { - int entnum; + pr_uint_t entnum; int dest; edict_t *ent; @@ -1256,7 +1257,7 @@ PF_setspawnparms (progs_t *pr) { client_t *client; edict_t *ent; - int i; + unsigned i; ent = P_EDICT (pr, 0); i = NUM_FOR_EDICT (pr, ent); diff --git a/nq/source/sv_user.c b/nq/source/sv_user.c index 0475efc0a..87623e7d6 100644 --- a/nq/source/sv_user.c +++ b/nq/source/sv_user.c @@ -584,7 +584,7 @@ SV_ReadClientMessage (void) void SV_RunClients (void) { - int i; + unsigned i; for (i = 0, host_client = svs.clients; i < svs.maxclients; i++, host_client++) { diff --git a/nq/source/world.c b/nq/source/world.c index 5f8bce898..a73e7c498 100644 --- a/nq/source/world.c +++ b/nq/source/world.c @@ -780,11 +780,10 @@ SV_ClipToLinks (areanode_t *node, moveclip_t *clip) edict_t *touch; link_t *l, *next; trace_t trace; - int i; if (clip->type == TL_EVERYTHING) { touch = NEXT_EDICT (&sv_pr_state, sv.edicts); - for (i = 1; i < sv.num_edicts; i++, + for (unsigned i = 1; i < sv.num_edicts; i++, touch = NEXT_EDICT (&sv_pr_state, touch)) { if (clip->trace.allsolid) return; @@ -897,7 +896,6 @@ SV_Move (const vec3_t start, const vec3_t mins, const vec3_t maxs, edict_t * SV_TestPlayerPosition (edict_t *ent, const vec3_t origin) { - int e; edict_t *check; hull_t *hull; vec3_t boxmins, boxmaxs, offset; @@ -912,8 +910,8 @@ SV_TestPlayerPosition (edict_t *ent, const vec3_t origin) VectorAdd (origin, SVvector (ent, maxs), boxmaxs); check = NEXT_EDICT (&sv_pr_state, sv.edicts); - for (e = 1; e < sv.num_edicts; e++, check = NEXT_EDICT (&sv_pr_state, - check)) { + for (unsigned e = 1; e < sv.num_edicts; + e++, check = NEXT_EDICT (&sv_pr_state, check)) { if (check->free) continue; if (check == ent) diff --git a/qw/include/server.h b/qw/include/server.h index ebe9cf2ce..bd7fb8062 100644 --- a/qw/include/server.h +++ b/qw/include/server.h @@ -81,7 +81,7 @@ typedef struct { const char *lightstyles[MAX_LIGHTSTYLES]; struct model_s *models[MAX_MODELS]; - int num_edicts; // increases towards MAX_EDICTS + unsigned num_edicts; // increases towards MAX_EDICTS struct edict_s *edicts; // can NOT be array indexed, because // struct edict_s is variable sized, but can // be used to reference the world ent @@ -304,8 +304,8 @@ typedef struct { int spawncount; // number of servers spawned since start, // used to check late spawns client_t clients[MAX_CLIENTS]; - int maxclients; - int num_clients; + unsigned maxclients; + unsigned num_clients; int serverflags; // episode completion information void (*phys_client) (struct edict_s *ent, int num); diff --git a/qw/include/sv_progs.h b/qw/include/sv_progs.h index 88fe18c24..d0c04e2e0 100644 --- a/qw/include/sv_progs.h +++ b/qw/include/sv_progs.h @@ -38,12 +38,12 @@ #include "sv_pr_cmds.h" typedef struct { - pr_int_t *self; - pr_int_t *other; - pr_int_t *world; + pr_uint_t *self; + pr_uint_t *other; + pr_uint_t *world; float *time; float *frametime; - pr_int_t *newmis; + pr_uint_t *newmis; float *force_retouch; string_t *mapname; float *serverflags; @@ -61,10 +61,10 @@ typedef struct { vec3_t *trace_endpos; vec3_t *trace_plane_normal; float *trace_plane_dist; - pr_int_t *trace_ent; + pr_uint_t *trace_ent; float *trace_inopen; float *trace_inwater; - pr_int_t *msg_entity; + pr_uint_t *msg_entity; float *skill; } sv_globals_t; diff --git a/qw/source/sv_init.c b/qw/source/sv_init.c index 30a0a12d2..929cd4853 100644 --- a/qw/source/sv_init.c +++ b/qw/source/sv_init.c @@ -122,11 +122,8 @@ SV_FlushSignon (void) static void SV_CreateBaseline (void) { - int entnum; - edict_t *svent; - - for (entnum = 0; entnum < sv.num_edicts; entnum++) { - svent = EDICT_NUM (&sv_pr_state, entnum); + for (unsigned entnum = 0; entnum < sv.num_edicts; entnum++) { + edict_t *svent = EDICT_NUM (&sv_pr_state, entnum); if (svent->free) continue; // create baselines for all player slots, diff --git a/qw/source/sv_phys.c b/qw/source/sv_phys.c index 79047699e..856a5ef16 100644 --- a/qw/source/sv_phys.c +++ b/qw/source/sv_phys.c @@ -417,7 +417,7 @@ static qboolean SV_Push (edict_t *pusher, const vec3_t tmove, const vec3_t amove) { float solid_save; - int num_moved, i, e; + int num_moved, i; edict_t *check, *block; edict_t **moved_edict; vec3_t move, org, org2; @@ -458,7 +458,7 @@ SV_Push (edict_t *pusher, const vec3_t tmove, const vec3_t amove) // see if any solid entities are inside the final position num_moved = 0; check = NEXT_EDICT (&sv_pr_state, sv.edicts); - for (e = 1; e < sv.num_edicts; + for (unsigned e = 1; e < sv.num_edicts; e++, check = NEXT_EDICT (&sv_pr_state, check)) { if (check->free) continue; @@ -862,14 +862,14 @@ void SV_Physics (void) { edict_t *ent; - int i; SV_ProgStartFrame (); // treat each object in turn // even the world gets a chance to think ent = sv.edicts; - for (i = 0; i < sv.num_edicts; i++, ent = NEXT_EDICT (&sv_pr_state, ent)) { + for (unsigned i = 0; i < sv.num_edicts; + i++, ent = NEXT_EDICT (&sv_pr_state, ent)) { if (ent->free) continue; diff --git a/qw/source/sv_pr_cmds.c b/qw/source/sv_pr_cmds.c index 2e1144780..1431729ee 100644 --- a/qw/source/sv_pr_cmds.c +++ b/qw/source/sv_pr_cmds.c @@ -653,7 +653,6 @@ PF_findradius (progs_t *pr) edict_t *ent, *chain; float rsqr; vec_t *emins, *emaxs, *org; - int i, j; vec3_t eorg; chain = (edict_t *) sv.edicts; @@ -663,7 +662,7 @@ PF_findradius (progs_t *pr) rsqr *= rsqr; // Square early, sqrt never ent = NEXT_EDICT (pr, sv.edicts); - for (i = 1; i < sv.num_edicts; i++, ent = NEXT_EDICT (pr, ent)) { + for (unsigned i = 1; i < sv.num_edicts; i++, ent = NEXT_EDICT (pr, ent)) { if (ent->free) continue; if (SVfloat (ent, solid) == SOLID_NOT @@ -671,7 +670,7 @@ PF_findradius (progs_t *pr) continue; emins = SVvector (ent, absmin); emaxs = SVvector (ent, absmax); - for (j = 0; j < 3; j++) + for (int j = 0; j < 3; j++) eorg[j] = org[j] - 0.5 * (emins[j] + emaxs[j]); if (DotProduct (eorg, eorg) > rsqr) continue; @@ -936,7 +935,7 @@ PF_aim (progs_t *pr) edict_t *ent, *check, *bestent; float dist, bestdist, speed; float *mins, *maxs, *org; - int i, j; + unsigned i, j; trace_t tr; vec3_t start, dir, end, bestdir; diff --git a/qw/source/sv_progs.c b/qw/source/sv_progs.c index 6351317e8..87b871ec9 100644 --- a/qw/source/sv_progs.c +++ b/qw/source/sv_progs.c @@ -65,7 +65,7 @@ cvar_t *pr_checkextensions; cvar_t *sv_old_entity_free; cvar_t *sv_hide_version_info; -static int reserved_edicts = MAX_CLIENTS; +static pr_uint_t reserved_edicts = MAX_CLIENTS; static int sv_range; diff --git a/qw/source/sv_user.c b/qw/source/sv_user.c index e73835a39..490127b33 100644 --- a/qw/source/sv_user.c +++ b/qw/source/sv_user.c @@ -491,16 +491,13 @@ SV_Spawn_f (void *unused) static void SV_SpawnSpectator (void) { - int i; - edict_t *e; - VectorZero (SVvector (sv_player, origin)); VectorZero (SVvector (sv_player, view_ofs)); SVvector (sv_player, view_ofs)[2] = 22; // search for an info_playerstart to spawn the spectator at - for (i = MAX_CLIENTS - 1; i < sv.num_edicts; i++) { - e = EDICT_NUM (&sv_pr_state, i); + for (unsigned i = MAX_CLIENTS - 1; i < sv.num_edicts; i++) { + edict_t *e = EDICT_NUM (&sv_pr_state, i); if (!strcmp (PR_GetString (&sv_pr_state, SVstring (e, classname)), "info_player_start")) { VectorCopy (SVvector (e, origin), SVvector (sv_player, origin)); @@ -1516,7 +1513,7 @@ static void AddLinksToPmove (areanode_t *node) { edict_t *check; - int pl, i; + pr_uint_t pl, i; link_t *l, *next; physent_t *pe; diff --git a/qw/source/world.c b/qw/source/world.c index 393daaf6f..877db0f38 100644 --- a/qw/source/world.c +++ b/qw/source/world.c @@ -818,11 +818,10 @@ SV_ClipToLinks (areanode_t *node, moveclip_t *clip) edict_t *touch; link_t *l, *next; trace_t trace; - int i; if (clip->type & MOVE_EVERYTHING) { touch = NEXT_EDICT (&sv_pr_state, sv.edicts); - for (i = 1; i < sv.num_edicts; i++, + for (unsigned i = 1; i < sv.num_edicts; i++, touch = NEXT_EDICT (&sv_pr_state, touch)) { if (clip->trace.allsolid) return; @@ -985,7 +984,6 @@ SV_Move (const vec3_t start, const vec3_t mins, const vec3_t maxs, edict_t * SV_TestPlayerPosition (edict_t *ent, const vec3_t origin) { - int e; edict_t *check; hull_t *hull; vec3_t boxmins, boxmaxs, offset; @@ -1000,8 +998,8 @@ SV_TestPlayerPosition (edict_t *ent, const vec3_t origin) VectorAdd (origin, SVvector (ent, maxs), boxmaxs); check = NEXT_EDICT (&sv_pr_state, sv.edicts); - for (e = 1; e < sv.num_edicts; e++, check = NEXT_EDICT (&sv_pr_state, - check)) { + for (unsigned e = 1; e < sv.num_edicts; + e++, check = NEXT_EDICT (&sv_pr_state, check)) { if (check->free) continue; if (check == ent) diff --git a/tools/qfcc/source/qfprogs.c b/tools/qfcc/source/qfprogs.c index 19c7ed873..1d60336a4 100644 --- a/tools/qfcc/source/qfprogs.c +++ b/tools/qfcc/source/qfprogs.c @@ -126,8 +126,8 @@ static const char *short_options = ; static edict_t *edicts; -static int num_edicts; -static int reserved_edicts = 1; +static pr_uint_t num_edicts; +static pr_uint_t reserved_edicts = 1; static progs_t pr; static qfo_t *qfo; diff --git a/tools/qfcc/test/test-harness.c b/tools/qfcc/test/test-harness.c index 5b0199317..42b6a9935 100644 --- a/tools/qfcc/test/test-harness.c +++ b/tools/qfcc/test/test-harness.c @@ -75,8 +75,8 @@ static const char *short_options = static edict_t test_edicts[MAX_EDICTS]; static edict_t *edicts; -static int num_edicts; -static int reserved_edicts; +static pr_uint_t num_edicts; +static pr_uint_t reserved_edicts; static progs_t test_pr; static const char *this_program; From 1397c94ef54c4a4ee98594df02cf80d769ed662a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 16 Jan 2022 22:17:17 +0900 Subject: [PATCH 119/360] [gamecode] Add tests for the state instructions --- libs/gamecode/test/Makemodule.am | 5 ++ libs/gamecode/test/head.c | 10 ++++ libs/gamecode/test/main.c | 14 +++++ libs/gamecode/test/test-state.c | 99 ++++++++++++++++++++++++++++++++ 4 files changed, 128 insertions(+) create mode 100644 libs/gamecode/test/test-state.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index d63023468..e0d60336d 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -18,6 +18,7 @@ libs_gamecode_tests = \ libs/gamecode/test/test-mem \ libs/gamecode/test/test-scale \ libs/gamecode/test/test-stack \ + libs/gamecode/test/test-state \ libs/gamecode/test/test-store \ libs/gamecode/test/test-string \ libs/gamecode/test/test-swizzle \ @@ -130,6 +131,10 @@ libs_gamecode_test_test_stack_SOURCES= \ libs_gamecode_test_test_stack_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_stack_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_state_SOURCES= \ + libs/gamecode/test/test-state.c +libs_gamecode_test_test_state_LDADD= $(test_gamecode_libs) + libs_gamecode_test_test_store_SOURCES= \ libs/gamecode/test/test-store.c libs_gamecode_test_test_store_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/head.c b/libs/gamecode/test/head.c index 478a74f09..9116bb695 100644 --- a/libs/gamecode/test/head.c +++ b/libs/gamecode/test/head.c @@ -36,4 +36,14 @@ typedef struct { pr_int_t *expect_globals; const char *strings; pr_uint_t string_size; + // pointers/globals for state + double *double_time; + pr_uint_t dtime; + float *float_time; + pr_uint_t ftime; + pr_uint_t self; + // fields for state + pr_uint_t think; + pr_uint_t nextthink; + pr_uint_t frame; } test_t; diff --git a/libs/gamecode/test/main.c b/libs/gamecode/test/main.c index 8f433225c..ddae815dd 100644 --- a/libs/gamecode/test/main.c +++ b/libs/gamecode/test/main.c @@ -108,6 +108,20 @@ setup_test (test_t *test) if (test->edict_area) { test_pr.pr_edict_area = test_pr.pr_globals + test->edict_area; } + if (test->double_time || test->float_time) { + test_pr.fields.nextthink = test->nextthink; + test_pr.fields.frame = test->frame; + test_pr.fields.think = test->think; + test_pr.globals.self = (pr_uint_t *) &test_pr.pr_globals[test->self]; + if (test->double_time) { + test_pr.globals.dtime = (double *)&test_pr.pr_globals[test->dtime]; + *test_pr.globals.dtime = *test->double_time; + } + if (test->float_time) { + test_pr.globals.ftime = (float *) &test_pr.pr_globals[test->ftime]; + *test_pr.globals.ftime = *test->float_time; + } + } test_progs.numstatements = test->num_statements + 1; test_pr.pr_statements diff --git a/libs/gamecode/test/test-state.c b/libs/gamecode/test/test-state.c new file mode 100644 index 000000000..f7a45076d --- /dev/null +++ b/libs/gamecode/test/test-state.c @@ -0,0 +1,99 @@ +#include "head.c" + +#include "QF/mathlib.h" + +#define DB 0xdeadbeef + +static float float_time = 1; + +static pr_ivec4_t float_state_init[] = { + { 0, 0, DB, DB }, + { 10, 11, 20, 21 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, +}; + +#define f1 0x3f800000 +#define f11 0x3f8ccccd +#define f2 0x40000000 +static pr_ivec4_t float_state_expect[] = { + { 0, 8, f1, DB }, + { 10, 11, 20, 21 }, + { 0, 0, 0, 0 }, + { 10, 20, f11, 0 }, + { 11, 21, f2, 0 }, +}; + +static dstatement_t float_state_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 1 }, + { OP(0, 0, 0, OP_STATE_ft), 4, 6, 0 }, + { OP(0, 0, 0, OP_LEA_A), 8, 0, 1 }, + { OP(0, 0, 0, OP_STATE_ftt), 5, 7, 2 }, +}; + +static double double_time = 1; + +static pr_ivec4_t double_state_init[] = { + { 0, 0, DB, DB }, + { 10, 11, 20, 21 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, +}; + +#define d1l 0x00000000 +#define d1h 0x3ff00000 +#define d11l 0x9999999a +#define d11h 0x3ff19999 +#define d2l 0x00000000 +#define d2h 0x40000000 +static pr_ivec4_t double_state_expect[] = { + { 0, 8, d1l, d1h }, + { 10, 11, 20, 21 }, + { 0, 0, 0, 0 }, + { 10, 20, d11l, d11h }, + { 11, 21, d2l, d2h }, +}; + +static dstatement_t double_state_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 1 }, + { OP(0, 0, 0, OP_STATE_dt), 4, 6, 0 }, + { OP(0, 0, 0, OP_LEA_A), 8, 0, 1 }, + { OP(0, 0, 0, OP_STATE_dtt), 5, 7, 2 }, +}; + +test_t tests[] = { + { + .desc = "float state", + .num_globals = num_globals(float_state_init,float_state_expect), + .num_statements = num_statements (float_state_statements), + .statements = float_state_statements, + .init_globals = (pr_int_t *) float_state_init, + .expect_globals = (pr_int_t *) float_state_expect, + .self = 1, + .ftime = 2, + .float_time = &float_time, + .edict_area = 8, + .frame = 0, + .think = 1, + .nextthink = 2, + }, + { + .desc = "double state", + .num_globals = num_globals(double_state_init,double_state_expect), + .num_statements = num_statements (double_state_statements), + .statements = double_state_statements, + .init_globals = (pr_int_t *) double_state_init, + .expect_globals = (pr_int_t *) double_state_expect, + .self = 1, + .dtime = 2, + .double_time = &double_time, + .edict_area = 8, + .frame = 0, + .think = 1, + .nextthink = 2, + }, +}; + +#include "main.c" From 1baf17b780a9dca371f1955f07da038d80f407d0 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 09:34:16 +0900 Subject: [PATCH 120/360] [gamecode] Add tests for the jump instructions --- libs/gamecode/test/Makemodule.am | 6 +++ libs/gamecode/test/test-jump.c | 77 ++++++++++++++++++++++++++++++++ 2 files changed, 83 insertions(+) create mode 100644 libs/gamecode/test/test-jump.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index e0d60336d..9a5b9bf04 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -12,6 +12,7 @@ libs_gamecode_tests = \ libs/gamecode/test/test-float \ libs/gamecode/test/test-hops \ libs/gamecode/test/test-int \ + libs/gamecode/test/test-jump \ libs/gamecode/test/test-lea \ libs/gamecode/test/test-load \ libs/gamecode/test/test-long \ @@ -101,6 +102,11 @@ libs_gamecode_test_test_int_SOURCES= \ libs_gamecode_test_test_int_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_int_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_jump_SOURCES= \ + libs/gamecode/test/test-jump.c +libs_gamecode_test_test_jump_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_jump_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_lea_SOURCES= \ libs/gamecode/test/test-lea.c libs_gamecode_test_test_lea_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-jump.c b/libs/gamecode/test/test-jump.c new file mode 100644 index 000000000..59e40554d --- /dev/null +++ b/libs/gamecode/test/test-jump.c @@ -0,0 +1,77 @@ +#include "head.c" + +#define DB 0xdeadbeef + +static pr_int_t test_globals_init[] = { + DB, 1, 2, 3, DB, +}; + +static pr_int_t test_globals_expect[] = { + DB, 1, 2, 3, 1, +}; + +static dstatement_t jump_A_statements[] = { + { OP(0, 0, 0, OP_JUMP_A), 4, 0, 0 }, + { OP(0, 0, 0, OP_LEA_A), 1, 0, 0 }, + { OP(0, 0, 0, OP_LEA_A), 1, 0, 4 }, + { OP(0, 0, 0, OP_JUMP_A), 2, 0, 0 }, + { OP(0, 0, 0, OP_JUMP_A), -2, 0, 0 }, +}; + +static dstatement_t jump_B_statements[] = { + { OP(0, 0, 0, OP_JUMP_B), 3, 0, 0 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_LEA_A), 1, 0, 0 }, + { OP(0, 0, 0, OP_LEA_A), 1, 0, 4 }, +}; + +static dstatement_t jump_C_statements[] = { + { OP(0, 0, 0, OP_JUMP_C), 1, 2, 0 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_LEA_A), 1, 0, 0 }, + { OP(0, 0, 0, OP_LEA_A), 1, 0, 4 }, +}; + +static dstatement_t jump_D_statements[] = { + { OP(0, 0, 0, OP_JUMP_D), 1, 2, 0 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_LEA_A), 1, 0, 0 }, + { OP(0, 0, 0, OP_LEA_A), 1, 0, 4 }, +}; + +test_t tests[] = { + { + .desc = "jump A", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (jump_A_statements), + .statements = jump_A_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "jump B", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (jump_B_statements), + .statements = jump_B_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "jump C", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (jump_C_statements), + .statements = jump_C_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "jump D", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (jump_D_statements), + .statements = jump_D_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, +}; + +#include "main.c" From 1beadbf871244917a4b875bc3c91b4a22c78d6e0 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 09:57:54 +0900 Subject: [PATCH 121/360] [gamecode] Add tests for the branch instructions --- libs/gamecode/test/Makemodule.am | 6 + libs/gamecode/test/test-branch.c | 193 +++++++++++++++++++++++++++++++ 2 files changed, 199 insertions(+) create mode 100644 libs/gamecode/test/test-branch.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index 9a5b9bf04..b70014d48 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -1,4 +1,5 @@ libs_gamecode_tests = \ + libs/gamecode/test/test-branch \ libs/gamecode/test/test-bitops \ libs/gamecode/test/test-conv0 \ libs/gamecode/test/test-conv1 \ @@ -37,6 +38,11 @@ test_gamecode_libs= \ libs/gamecode/libQFgamecode.la \ libs/util/libQFutil.la +libs_gamecode_test_test_branch_SOURCES= \ + libs/gamecode/test/test-branch.c +libs_gamecode_test_test_branch_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_branch_DEPENDENCIES=$(test_gamecode_libs) + libs_gamecode_test_test_bitops_SOURCES= \ libs/gamecode/test/test-bitops.c libs_gamecode_test_test_bitops_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-branch.c b/libs/gamecode/test/test-branch.c new file mode 100644 index 000000000..e02f229ba --- /dev/null +++ b/libs/gamecode/test/test-branch.c @@ -0,0 +1,193 @@ +#include "head.c" + +#define DB 0xdeadbeef + +static pr_int_t test_globals_init[] = { + -1, 1, 0, DB, DB, +}; + +static pr_int_t test_globals_expect[] = { + -1, 1, 0, DB, 1, +}; + +static dstatement_t ifz_taken_statements[] = { + { OP_IFZ, 4, 0, 2 }, + { OP_LEA_A, 1, 0, 3 }, + { OP_LEA_A, 1, 0, 4 }, + { OP_BREAK }, + { OP_IFZ, -2, 0, 2 }, +}; + +static dstatement_t ifb_taken_statements[] = { + { OP_IFB, 4, 0, 0 }, + { OP_LEA_A, 1, 0, 3 }, + { OP_LEA_A, 1, 0, 4 }, + { OP_BREAK }, + { OP_IFB, -2, 0, 0 }, +}; + +static dstatement_t ifa_taken_statements[] = { + { OP_IFA, 4, 0, 1 }, + { OP_LEA_A, 1, 0, 3 }, + { OP_LEA_A, 1, 0, 4 }, + { OP_BREAK }, + { OP_IFA, -2, 0, 1 }, +}; + +static dstatement_t ifnz_taken_statements[] = { + { OP_IFNZ, 4, 0, 0 }, + { OP_LEA_A, 1, 0, 3 }, + { OP_LEA_A, 1, 0, 4 }, + { OP_BREAK }, + { OP_IFNZ, -2, 0, 1 }, +}; + +static dstatement_t ifae_taken_statements[] = { + { OP_IFAE, 4, 0, 1 }, + { OP_LEA_A, 1, 0, 3 }, + { OP_LEA_A, 1, 0, 4 }, + { OP_BREAK }, + { OP_IFAE, -2, 0, 2 }, +}; + +static dstatement_t ifbe_taken_statements[] = { + { OP_IFBE, 4, 0, 0 }, + { OP_LEA_A, 1, 0, 3 }, + { OP_LEA_A, 1, 0, 4 }, + { OP_BREAK }, + { OP_IFBE, -2, 0, 2 }, +}; + +static dstatement_t ifz_not_taken_statements[] = { + { OP_IFZ, 3, 0, 0 }, + { OP_IFZ, 2, 0, 1 }, + { OP_LEA_A, 1, 0, 4 }, +}; + +static dstatement_t ifb_not_taken_statements[] = { + { OP_IFB, 3, 0, 2 }, + { OP_IFB, 2, 0, 1 }, + { OP_LEA_A, 1, 0, 4 }, +}; + +static dstatement_t ifa_not_taken_statements[] = { + { OP_IFA, 3, 0, 2 }, + { OP_IFA, 2, 0, 0 }, + { OP_LEA_A, 1, 0, 4 }, +}; + +static dstatement_t ifnz_not_taken_statements[] = { + { OP_IFNZ, 3, 0, 2 }, + { OP_LEA_A, 1, 0, 4 }, +}; + +static dstatement_t ifae_not_taken_statements[] = { + { OP_IFAE, 2, 0, 0 }, + { OP_LEA_A, 1, 0, 4 }, +}; + +static dstatement_t ifbe_not_taken_statements[] = { + { OP_IFBE, 2, 0, 1 }, + { OP_LEA_A, 1, 0, 4 }, +}; + +test_t tests[] = { + { + .desc = "ifz taken", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (ifz_taken_statements), + .statements = ifz_taken_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "ifb taken", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (ifb_taken_statements), + .statements = ifb_taken_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "ifa taken", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (ifa_taken_statements), + .statements = ifa_taken_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "ifnz taken", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (ifnz_taken_statements), + .statements = ifnz_taken_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "ifae taken", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (ifae_taken_statements), + .statements = ifae_taken_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "ifbe taken", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (ifbe_taken_statements), + .statements = ifbe_taken_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "ifz not taken", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (ifz_not_taken_statements), + .statements = ifz_not_taken_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "ifb not taken", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (ifb_not_taken_statements), + .statements = ifb_not_taken_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "ifa not taken", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (ifa_not_taken_statements), + .statements = ifa_not_taken_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "ifnz not taken", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (ifnz_not_taken_statements), + .statements = ifnz_not_taken_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "ifae not taken", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (ifae_not_taken_statements), + .statements = ifae_not_taken_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "ifbe not taken", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (ifbe_not_taken_statements), + .statements = ifbe_not_taken_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, +}; + +#include "main.c" From 56d8bdee825b4febc51d11bb82b8bc492cc2d008 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 10:32:19 +0900 Subject: [PATCH 122/360] [gamecode] Add a fixme about using gcc's vec convert It might produce better code than the way I'm currently doing it. --- libs/gamecode/convert.py | 1 + 1 file changed, 1 insertion(+) diff --git a/libs/gamecode/convert.py b/libs/gamecode/convert.py index 0474fbd8f..333846c66 100644 --- a/libs/gamecode/convert.py +++ b/libs/gamecode/convert.py @@ -52,6 +52,7 @@ def case_str(width, src_type, dst_type): case = (width << 6) | (src_type << 3) | (dst_type) return f"case {case:04o}:" +#FIXME look into using gcc's __builtin_convertvector def cast_str(width, src_type, dst_type): if width & 1: return f"(pr_{vec_types[dst_type]}{width+1}_t)" From b3909dbe4c473aee202c2462f32f849801f665c0 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 14:26:12 +0900 Subject: [PATCH 123/360] [gamecode] Add a test for call and return It currently fails for two reasons: - call's mode selection is incorrect (never updated from when there was only the one call instruction and the mode was encoded in operand c) - return should automatically restore the stack pointer to the value it had on entry to the function, thus allowing local values stored on the stack to be safely returned. --- libs/gamecode/test/Makemodule.am | 6 ++ libs/gamecode/test/head.c | 5 ++ libs/gamecode/test/main.c | 14 ++++- libs/gamecode/test/test-callret.c | 96 +++++++++++++++++++++++++++++++ 4 files changed, 120 insertions(+), 1 deletion(-) create mode 100644 libs/gamecode/test/test-callret.c diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index b70014d48..1fd3353bf 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -1,6 +1,7 @@ libs_gamecode_tests = \ libs/gamecode/test/test-branch \ libs/gamecode/test/test-bitops \ + libs/gamecode/test/test-callret \ libs/gamecode/test/test-conv0 \ libs/gamecode/test/test-conv1 \ libs/gamecode/test/test-conv2 \ @@ -48,6 +49,11 @@ libs_gamecode_test_test_bitops_SOURCES= \ libs_gamecode_test_test_bitops_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_bitops_DEPENDENCIES=$(test_gamecode_libs) +libs_gamecode_test_test_callret_SOURCES= \ + libs/gamecode/test/test-callret.c +libs_gamecode_test_test_callret_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_callret_DEPENDENCIES=$(test_gamecode_libs) + libs_gamecode_test_test_conv0_SOURCES= \ libs/gamecode/test/test-conv0.c libs_gamecode_test_test_conv0_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/head.c b/libs/gamecode/test/head.c index 9116bb695..07921d847 100644 --- a/libs/gamecode/test/head.c +++ b/libs/gamecode/test/head.c @@ -21,6 +21,9 @@ static int verbose = 0; #define num_statements(statements) \ (sizeof (statements) / sizeof (statements[0])) +#define num_functions(functions) \ + (sizeof (functions) / sizeof (functions[0])) + #define BASE(b, base) (((base) & 3) << OP_##b##_SHIFT) #define OP(a, b, c, op) ((op) | BASE(A, a) | BASE(B, b) | BASE(C, c)) @@ -46,4 +49,6 @@ typedef struct { pr_uint_t think; pr_uint_t nextthink; pr_uint_t frame; + bfunction_t *functions; + pr_uint_t num_functions; } test_t; diff --git a/libs/gamecode/test/main.c b/libs/gamecode/test/main.c index ddae815dd..7a565dece 100644 --- a/libs/gamecode/test/main.c +++ b/libs/gamecode/test/main.c @@ -88,7 +88,16 @@ setup_test (test_t *test) test_pr.debug_data = &test_pr; test_pr.pr_trace = 1; test_pr.pr_trace_depth = -1; - test_pr.function_table = test_functions; + if (test->num_functions && test->functions) { + test_pr.function_table = calloc ((test->num_functions + 2), + sizeof (bfunction_t)); + memcpy (test_pr.function_table, test_functions, + 2 * sizeof (bfunction_t)); + memcpy (test_pr.function_table + 2, test->functions, + test->num_functions * sizeof (bfunction_t)); + } else { + test_pr.function_table = test_functions; + } pr_uint_t num_globals = test->num_globals; num_globals += test->extra_globals + test->stack_size; @@ -170,6 +179,9 @@ run_test (test_t *test) pr_uint_t num_globals = test->num_globals; num_globals += test->extra_globals + test->stack_size; + if (test->num_functions && test->functions) { + free (test_pr.function_table); + } Sys_Free (test_pr.pr_globals, num_globals * sizeof (pr_type_t)); free (test_pr.pr_statements); diff --git a/libs/gamecode/test/test-callret.c b/libs/gamecode/test/test-callret.c new file mode 100644 index 000000000..988f27936 --- /dev/null +++ b/libs/gamecode/test/test-callret.c @@ -0,0 +1,96 @@ +#include "head.c" + +#include "QF/mathlib.h" + +#define sq(x) ((float)(x)*(float)(x)) +#define pi_6 0x3f060a92 // pi/6 +#define r3_2 0x3f5db3d7 // sqrt(3)/2 +#define f1_2 0x3f000000 // 1/2 +#define f1 0x3f800000 // 1 +#define f2 0x40000000 // 2 +#define shx 0x3f0c4020 // sinh(pi/6) +#define chx 0x3f91f354 // cosh(pi/6) + +#define STK (32 * 4) // stack ptr just after globals + +static pr_ivec4_t float_callret_init[32] = { + { 0, pi_6, 2, 0}, + { f1, f2, 0, 0}, +}; + +static pr_ivec4_t float_callret_expect[32] = { + // constants + { 0, pi_6, 2, 0}, + { f1, f2, 0, 0}, + // result + { r3_2, f1_2, chx, shx }, +}; + +static dstatement_t float_callret_statements[] = { + { OP_STORE_A_1, 7, 0, STK }, // save stack pointer for check + { OP_PUSH_A_1, 1, 0, 0 }, + { OP_CALL_B, 2, 0, 8 }, + { OP_LEA_C, STK, 4, STK }, // discard param + { OP_SUB_I_1, 7, STK, 7 }, // check stack restored + { OP_BREAK }, +// cos_sin_cosh_sinh: +// calculate cos(x), sin(x), cosh(x) and sinh(x) simultaneously + { OP_WITH, 2, 0, 1 }, // put params into reg 1 + { OP_LEA_C, STK, -24, STK }, // reserve 24 words on the stack + { OP_WITH, 2, 0, 2 }, // put locals into reg 2 +#define x 0 // in parameters float +#define xn 0 // in locals vec4 +#define x2 4 // in locals vec4 +#define ac 8 // in locals vec4 +#define fa 12 // in locals vec4 +#define fi 16 // in locals vec4 +#define c 20 // in locals int + { OP(2, 0, 1, OP_STORE_A_1), xn+1,0, x }, // init xn to [1, x, 0, 0] + { OP(2, 0, 0, OP_STORE_A_1), xn, 0, 4 }, + { OP(2, 0, 2, OP_SWIZZLE_F), xn, 0x0044, xn }, // xn -> [1, x, 1, x] + { OP(1, 1, 2, OP_MUL_F_1), x, x, x2 }, // x2 -> [x*x, 0, 0, 0] + { OP(2, 0, 2, OP_SWIZZLE_F), x2, 0x0300, x2},//x2 -> [-x*x, -x*x, x*x, x*x] + { OP(2, 0, 0, OP_STORE_A_1), fa, 0, 4 }, // init factorial + { OP(2, 0, 0, OP_STORE_A_1), fa+1,0, 5 }, + { OP(2, 0, 2, OP_SWIZZLE_F), fa, 0x0044, fa }, // fa -> [1, 2, 1, 2] + { OP(0, 0, 2, OP_SWIZZLE_F), 4, 0x0000, fi }, // init fi -> [1, 1, 1, 1] + { OP(2, 2, 2, OP_SUB_F_4), ac, ac, ac }, // init acc (output) to 0 + { OP(0, 0, 2, OP_LEA_A), 25, 0, c }, // init count +// loop: + { OP(2, 2, 2, OP_ADD_F_4), ac, xn, ac }, // acc += xn + { OP(2, 2, 2, OP_MUL_F_4), xn, x2, xn }, // xn *= x2 + { OP(2, 2, 2, OP_DIV_F_4), xn, fa, xn }, // xn /= f + { OP(2, 2, 2, OP_ADD_F_4), fa, fi, fa }, // f += inc + { OP(2, 2, 2, OP_DIV_F_4), xn, fa, xn }, // xn /= f + { OP(2, 2, 2, OP_ADD_F_4), fa, fi, fa }, // f += inc + { OP(2, 0, 2, OP_LEA_C), c, -1, c }, // dec count + { OP(0, 0, 2, OP_IFA), -7, 0, c }, // count > 0 + { OP(2, 0, 0, OP_RETURN), ac, 0, 4 }, +}; +#undef x +#undef xn +#undef x2 +#undef ac +#undef fa +#undef fi +#undef c + +static bfunction_t callret_functions[] = { + { .first_statement = 6 }, +}; + +test_t tests[] = { + { + .desc = "callret", + .num_globals = num_globals(float_callret_init,float_callret_expect), + .num_statements = num_statements (float_callret_statements), + .statements = float_callret_statements, + .init_globals = (pr_int_t *) float_callret_init, + .expect_globals = (pr_int_t *) float_callret_expect, + .functions = callret_functions, + .num_functions = num_functions(callret_functions), + .stack_size = 128, + }, +}; + +#include "main.c" From cf3106ce28c92b85d4bbc590968e022eafd7ea05 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 14:29:14 +0900 Subject: [PATCH 124/360] [gamecode] Correct call's mode selection Call's operand c is used to specify where the return value of the function is to be stored. This gets both the correct function being called, and the value being returned correctly. Test still fails due to the stack restoration issue. --- libs/gamecode/pr_exec.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index adf9cf515..d2f55dbd7 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -3141,7 +3141,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_CALL_B: case OP_CALL_C: case OP_CALL_D: - mm = pr_call_mode (pr, st, st->c & 3); + mm = pr_call_mode (pr, st, st_op - OP_CALL_B + 1); function = mm->func_var; pr->pr_argc = 0; // op_c specifies the location for the return value if any From 8e5c2c65348e46e9f40bd6b2e0ce5119239fffde Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 14:43:43 +0900 Subject: [PATCH 125/360] [gamecode] Correct type of return address in stack This is another one of those "why signed?" things: can't have negative return addresses. --- include/QF/progs.h | 2 +- libs/gamecode/pr_debug.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index e8b4136dc..55ac37b69 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1801,7 +1801,7 @@ extern const char *pr_gametype; typedef struct strref_s strref_t; typedef struct { - pr_int_t staddr; ///< Return statement. + pr_uint_t staddr; ///< Return statement. bfunction_t *func; ///< Calling function. strref_t *tstr; ///< Linked list of temporary strings. } prstack_t; diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 1034c7b95..e4268eef5 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -1721,7 +1721,7 @@ dump_frame (progs_t *pr, prstack_t *frame) pr_lineno_t *lineno = PR_Find_Lineno (pr, frame->staddr); pr_auxfunction_t *func = PR_Get_Lineno_Func (pr, lineno); pr_uint_t line = PR_Get_Lineno_Line (pr, lineno); - pr_int_t addr = PR_Get_Lineno_Addr (pr, lineno); + pr_uint_t addr = PR_Get_Lineno_Addr (pr, lineno); line += func->source_line; if (addr == frame->staddr) { From 213434b7054d3f4991a52ea0b4346a7c15d94aec Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 14:45:14 +0900 Subject: [PATCH 126/360] [gamecode] Save and restore data stack in call stack This fixes the issue of the data stack not being restored properly because the returning function needs to return a value from its local variables (stored on the stack) and accessing stack data below the stack pointer is a bad idea (sure, no interrupts yet, but who knows...). --- include/QF/progs.h | 1 + libs/gamecode/pr_exec.c | 7 +++++++ 2 files changed, 8 insertions(+) diff --git a/include/QF/progs.h b/include/QF/progs.h index 55ac37b69..1597c97df 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1802,6 +1802,7 @@ typedef struct strref_s strref_t; typedef struct { pr_uint_t staddr; ///< Return statement. + pr_uint_t stack_ptr; ///< data stack on entry to function bfunction_t *func; ///< Calling function. strref_t *tstr; ///< Linked list of temporary strings. } prstack_t; diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index d2f55dbd7..cf01b0e8a 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -143,6 +143,9 @@ PR_PushFrame (progs_t *pr) frame = pr->pr_stack + pr->pr_depth++; frame->staddr = pr->pr_xstatement; + if (pr->globals.stack) { + frame->stack_ptr = *pr->globals.stack; + } frame->func = pr->pr_xfunction; frame->tstr = pr->pr_xtstr; @@ -179,6 +182,10 @@ PR_PopFrame (progs_t *pr) pr->pr_xfunction = frame->func; pr->pr_xstatement = frame->staddr; pr->pr_xtstr = frame->tstr; + // restore data stack (discard any locals) + if (pr->globals.stack) { + *pr->globals.stack = frame->stack_ptr; + } } static __attribute__((pure)) long From 8da1163a82247bc580c24f57a77a21d805c55230 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 14:59:17 +0900 Subject: [PATCH 127/360] [gamecode] Add bases check to callret test The base registers must be preserved across a function call and they currently are not, thus the updated test fails again. --- libs/gamecode/test/test-callret.c | 29 ++++++++++++++++++++++++----- 1 file changed, 24 insertions(+), 5 deletions(-) diff --git a/libs/gamecode/test/test-callret.c b/libs/gamecode/test/test-callret.c index 988f27936..269ff61a9 100644 --- a/libs/gamecode/test/test-callret.c +++ b/libs/gamecode/test/test-callret.c @@ -11,27 +11,46 @@ #define shx 0x3f0c4020 // sinh(pi/6) #define chx 0x3f91f354 // cosh(pi/6) +#define DB 0xdeadbeef + #define STK (32 * 4) // stack ptr just after globals static pr_ivec4_t float_callret_init[32] = { - { 0, pi_6, 2, 0}, - { f1, f2, 0, 0}, + { 0, pi_6, 2, 0}, + { f1, f2, 0, 0}, + // result + { DB, DB, DB, DB }, + // pre-call with + { DB, DB, DB, DB }, + // post-call with + { DB, DB, DB, DB }, + { DB, DB, DB, DB }, }; static pr_ivec4_t float_callret_expect[32] = { // constants - { 0, pi_6, 2, 0}, - { f1, f2, 0, 0}, + { 0, pi_6, 2, 0 }, + { f1, f2, 0, 0 }, // result { r3_2, f1_2, chx, shx }, + // pre-call with: should be all 0 on progs init + { 0, 0, 0, 0 }, + // post-call with; should be restored to pre-call values (in this case, + // progs init) + { 0, 0, 0, 0 }, + { DB, DB, DB, DB }, }; static dstatement_t float_callret_statements[] = { + { OP_WITH, 8, 0, 0 }, // pushregs + { OP_POP_A_4, 12, 0, 0 }, { OP_STORE_A_1, 7, 0, STK }, // save stack pointer for check { OP_PUSH_A_1, 1, 0, 0 }, { OP_CALL_B, 2, 0, 8 }, { OP_LEA_C, STK, 4, STK }, // discard param { OP_SUB_I_1, 7, STK, 7 }, // check stack restored + { OP_WITH, 8, 0, 0 }, // pushregs + { OP_POP_A_4, 16, 0, 0 }, { OP_BREAK }, // cos_sin_cosh_sinh: // calculate cos(x), sin(x), cosh(x) and sinh(x) simultaneously @@ -76,7 +95,7 @@ static dstatement_t float_callret_statements[] = { #undef c static bfunction_t callret_functions[] = { - { .first_statement = 6 }, + { .first_statement = 10 }, }; test_t tests[] = { From 736387bc888331b9c044ad845705a2b7db96548f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 15:08:58 +0900 Subject: [PATCH 128/360] [gamecode] Preserve base registers across calls With this, functions can call other functions without having to worry about whether the base registers they set up are still valid. --- include/QF/progs.h | 1 + libs/gamecode/pr_exec.c | 2 ++ 2 files changed, 3 insertions(+) diff --git a/include/QF/progs.h b/include/QF/progs.h index 1597c97df..d2a923743 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1801,6 +1801,7 @@ extern const char *pr_gametype; typedef struct strref_s strref_t; typedef struct { + pr_uivec4_t bases; ///< base registers on entry to function pr_uint_t staddr; ///< Return statement. pr_uint_t stack_ptr; ///< data stack on entry to function bfunction_t *func; ///< Calling function. diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index cf01b0e8a..46d474a7b 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -146,6 +146,7 @@ PR_PushFrame (progs_t *pr) if (pr->globals.stack) { frame->stack_ptr = *pr->globals.stack; } + frame->bases = pr->pr_bases; frame->func = pr->pr_xfunction; frame->tstr = pr->pr_xtstr; @@ -182,6 +183,7 @@ PR_PopFrame (progs_t *pr) pr->pr_xfunction = frame->func; pr->pr_xstatement = frame->staddr; pr->pr_xtstr = frame->tstr; + pr->pr_bases = frame->bases; // restore data stack (discard any locals) if (pr->globals.stack) { *pr->globals.stack = frame->stack_ptr; From 94ef9931a571f5488a9c6d2d69f2cb6c99d0b20c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 16:27:50 +0900 Subject: [PATCH 129/360] [gamecode] Add two more call/return tests The two tests check that 32 words can be returned (fails) and that function calls can be nested and their values returned properly (also fails). --- libs/gamecode/test/test-callret.c | 113 ++++++++++++++++++++++++++---- 1 file changed, 101 insertions(+), 12 deletions(-) diff --git a/libs/gamecode/test/test-callret.c b/libs/gamecode/test/test-callret.c index 269ff61a9..64a597ce7 100644 --- a/libs/gamecode/test/test-callret.c +++ b/libs/gamecode/test/test-callret.c @@ -15,7 +15,7 @@ #define STK (32 * 4) // stack ptr just after globals -static pr_ivec4_t float_callret_init[32] = { +static pr_ivec4_t callret_init[32] = { { 0, pi_6, 2, 0}, { f1, f2, 0, 0}, // result @@ -27,7 +27,7 @@ static pr_ivec4_t float_callret_init[32] = { { DB, DB, DB, DB }, }; -static pr_ivec4_t float_callret_expect[32] = { +static pr_ivec4_t callret_expect[32] = { // constants { 0, pi_6, 2, 0 }, { f1, f2, 0, 0 }, @@ -41,7 +41,7 @@ static pr_ivec4_t float_callret_expect[32] = { { DB, DB, DB, DB }, }; -static dstatement_t float_callret_statements[] = { +static dstatement_t callret_statements[] = { { OP_WITH, 8, 0, 0 }, // pushregs { OP_POP_A_4, 12, 0, 0 }, { OP_STORE_A_1, 7, 0, STK }, // save stack pointer for check @@ -54,6 +54,7 @@ static dstatement_t float_callret_statements[] = { { OP_BREAK }, // cos_sin_cosh_sinh: // calculate cos(x), sin(x), cosh(x) and sinh(x) simultaneously +[32]= { OP_WITH, 2, 0, 1 }, // put params into reg 1 { OP_LEA_C, STK, -24, STK }, // reserve 24 words on the stack { OP_WITH, 2, 0, 2 }, // put locals into reg 2 @@ -67,12 +68,12 @@ static dstatement_t float_callret_statements[] = { { OP(2, 0, 1, OP_STORE_A_1), xn+1,0, x }, // init xn to [1, x, 0, 0] { OP(2, 0, 0, OP_STORE_A_1), xn, 0, 4 }, { OP(2, 0, 2, OP_SWIZZLE_F), xn, 0x0044, xn }, // xn -> [1, x, 1, x] - { OP(1, 1, 2, OP_MUL_F_1), x, x, x2 }, // x2 -> [x*x, 0, 0, 0] + { OP(1, 1, 2, OP_MUL_F_1), x, x, x2 }, // x2 -> [x*x, ?, ?, ?] { OP(2, 0, 2, OP_SWIZZLE_F), x2, 0x0300, x2},//x2 -> [-x*x, -x*x, x*x, x*x] { OP(2, 0, 0, OP_STORE_A_1), fa, 0, 4 }, // init factorial { OP(2, 0, 0, OP_STORE_A_1), fa+1,0, 5 }, { OP(2, 0, 2, OP_SWIZZLE_F), fa, 0x0044, fa }, // fa -> [1, 2, 1, 2] - { OP(0, 0, 2, OP_SWIZZLE_F), 4, 0x0000, fi }, // init fi -> [1, 1, 1, 1] + { OP(2, 0, 2, OP_SWIZZLE_F), fa, 0x0000, fi }, // init fi -> [1, 1, 1, 1] { OP(2, 2, 2, OP_SUB_F_4), ac, ac, ac }, // init acc (output) to 0 { OP(0, 0, 2, OP_LEA_A), 25, 0, c }, // init count // loop: @@ -85,7 +86,6 @@ static dstatement_t float_callret_statements[] = { { OP(2, 0, 2, OP_LEA_C), c, -1, c }, // dec count { OP(0, 0, 2, OP_IFA), -7, 0, c }, // count > 0 { OP(2, 0, 0, OP_RETURN), ac, 0, 4 }, -}; #undef x #undef xn #undef x2 @@ -93,19 +93,108 @@ static dstatement_t float_callret_statements[] = { #undef fa #undef fi #undef c +}; + +static pr_ivec4_t call32_init[32] = { + { 0, 2, 0, 0 }, + { DB, DB, DB, DB }, + { DB, DB, DB, DB }, + { DB, DB, DB, DB }, + { DB, DB, DB, DB }, + { DB, DB, DB, DB }, + { DB, DB, DB, DB }, + { DB, DB, DB, DB }, + { DB, DB, DB, DB }, +}; + +static pr_ivec4_t call32_expect[32] = { + { 0, 2, 0, 0 }, + { 0, 1, 2, 3 }, + { 4, 5, 6, 7 }, + { 8, 9, 10, 11 }, + { 12, 13, 14, 15 }, + { 16, 17, 18, 19 }, + { 20, 21, 22, 23 }, + { 24, 25, 26, 27 }, + { 28, 29, 30, 31 }, +}; + +static dstatement_t call32_statements[] = { + { OP_CALL_B, 1, 0, 4 }, + { OP_BREAK }, +[32]= + { OP_LEA_C, STK, -36, STK }, // reserve 36 words on the stack + { OP_WITH, 2, 0, 2 }, // put locals into reg 2 + { OP(0, 0, 2, OP_LEA_A), 32, 0, 32 }, // init index + { OP(2, 0, 2, OP_LEA_A), 0, 0, 33 }, // init base to array +//loop: + { OP(0, 0, 2, OP_IFBE), 4, 0, 32 }, // if index-- > 0 + { OP(2, 0, 2, OP_LEA_C), 32, -1, 32 }, + { OP(2, 2, 2, OP_STORE_D_1), 33, 32, 32 }, // array[index] = index + { OP(0, 0, 0, OP_JUMP_A), -3, 0, 0 }, + { OP(2, 0, 0, OP_RETURN), 0, 0, 32 }, +}; + +static pr_ivec4_t callchain_init[32] = { + { 0, 2, 3, 0 }, + { DB, DB, DB, DB }, +}; + +static pr_ivec4_t callchain_expect[32] = { + { 0, 2, 3, 0 }, + { 42, DB, DB, DB }, +}; + +static dstatement_t callchain_statements[] = { + { OP_CALL_B, 1, 0, 4 }, + { OP_BREAK }, +[32]= + { OP_LEA_C, STK, -4, STK }, // reserve 4 words on the stack + { OP_WITH, 2, 0, 2 }, // put locals into reg 2 + { OP(0, 0, 2, OP_CALL_B), 2, 0, 0 }, + { OP(2, 0, 0, OP_RETURN), 0, 0, 1 }, +[64]= + { OP_LEA_C, STK, -4, STK }, // reserve 4 words on the stack + { OP_WITH, 2, 0, 2 }, // put locals into reg 2 + { OP(0, 0, 2, OP_LEA_A), 42, 0, 0 }, // init value + { OP(2, 0, 0, OP_RETURN), 0, 0, 1 }, // return value +}; static bfunction_t callret_functions[] = { - { .first_statement = 10 }, + { .first_statement = 32 }, + { .first_statement = 64 }, }; test_t tests[] = { { .desc = "callret", - .num_globals = num_globals(float_callret_init,float_callret_expect), - .num_statements = num_statements (float_callret_statements), - .statements = float_callret_statements, - .init_globals = (pr_int_t *) float_callret_init, - .expect_globals = (pr_int_t *) float_callret_expect, + .num_globals = num_globals(callret_init,callret_expect), + .num_statements = num_statements (callret_statements), + .statements = callret_statements, + .init_globals = (pr_int_t *) callret_init, + .expect_globals = (pr_int_t *) callret_expect, + .functions = callret_functions, + .num_functions = num_functions(callret_functions), + .stack_size = 128, + }, + { + .desc = "call32", + .num_globals = num_globals(call32_init,call32_expect), + .num_statements = num_statements (call32_statements), + .statements = call32_statements, + .init_globals = (pr_int_t *) call32_init, + .expect_globals = (pr_int_t *) call32_expect, + .functions = callret_functions, + .num_functions = num_functions(callret_functions), + .stack_size = 128, + }, + { + .desc = "callchain", + .num_globals = num_globals(callchain_init,callchain_expect), + .num_statements = num_statements (callchain_statements), + .statements = callchain_statements, + .init_globals = (pr_int_t *) callchain_init, + .expect_globals = (pr_int_t *) callchain_expect, .functions = callret_functions, .num_functions = num_functions(callret_functions), .stack_size = 128, From 89e120ba3436f3916822dc09d32001fd53beff14 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 16:54:27 +0900 Subject: [PATCH 130/360] [gamecode] Make return support 32 words This took interpreting the lower 5 bits of operand c as size - 1, and 0xffff as void (0 words). --- libs/gamecode/pr_exec.c | 6 +++--- libs/gamecode/test/test-callret.c | 8 ++++---- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 46d474a7b..90296c153 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -3131,9 +3131,9 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) break; OP_cmp_T (LT, U, long, lvec2, lvec4, <, ulong, ulvec2, ulvec4); case OP_RETURN: - int ret_size = st->c & 0x1f; // up to 32 words - if (ret_size) { - mm = pr_return_mode (pr, st, (st->c >> 5) & 7); + int ret_size = (st->c & 0x1f) + 1; // up to 32 words + if (st->c != 0xffff) { + mm = pr_return_mode (pr, st, st->c >> 5); memcpy (&R_INT (pr), mm, ret_size * sizeof (*op_a)); } pr->pr_xfunction->profile += profile - startprofile; diff --git a/libs/gamecode/test/test-callret.c b/libs/gamecode/test/test-callret.c index 64a597ce7..9bf96fa54 100644 --- a/libs/gamecode/test/test-callret.c +++ b/libs/gamecode/test/test-callret.c @@ -85,7 +85,7 @@ static dstatement_t callret_statements[] = { { OP(2, 2, 2, OP_ADD_F_4), fa, fi, fa }, // f += inc { OP(2, 0, 2, OP_LEA_C), c, -1, c }, // dec count { OP(0, 0, 2, OP_IFA), -7, 0, c }, // count > 0 - { OP(2, 0, 0, OP_RETURN), ac, 0, 4 }, + { OP(2, 0, 0, OP_RETURN), ac, 0, 3 }, // size is (c&31)+1 #undef x #undef xn #undef x2 @@ -132,7 +132,7 @@ static dstatement_t call32_statements[] = { { OP(2, 0, 2, OP_LEA_C), 32, -1, 32 }, { OP(2, 2, 2, OP_STORE_D_1), 33, 32, 32 }, // array[index] = index { OP(0, 0, 0, OP_JUMP_A), -3, 0, 0 }, - { OP(2, 0, 0, OP_RETURN), 0, 0, 32 }, + { OP(2, 0, 0, OP_RETURN), 0, 0, 0x1f }, // only bits 0-5 are size }; static pr_ivec4_t callchain_init[32] = { @@ -152,12 +152,12 @@ static dstatement_t callchain_statements[] = { { OP_LEA_C, STK, -4, STK }, // reserve 4 words on the stack { OP_WITH, 2, 0, 2 }, // put locals into reg 2 { OP(0, 0, 2, OP_CALL_B), 2, 0, 0 }, - { OP(2, 0, 0, OP_RETURN), 0, 0, 1 }, + { OP(2, 0, 0, OP_RETURN), 0, 0, 0 }, [64]= { OP_LEA_C, STK, -4, STK }, // reserve 4 words on the stack { OP_WITH, 2, 0, 2 }, // put locals into reg 2 { OP(0, 0, 2, OP_LEA_A), 42, 0, 0 }, // init value - { OP(2, 0, 0, OP_RETURN), 0, 0, 1 }, // return value + { OP(2, 0, 0, OP_RETURN), 0, 0, 0 }, // return value }; static bfunction_t callret_functions[] = { From 306fcbfbd0261f6e4e1e0e565f3d1442cc14eda9 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 16:55:39 +0900 Subject: [PATCH 131/360] [gamecode] Improve callchain test Add another function call to further mess up the return value address and verify just where it is pointing. --- libs/gamecode/test/test-callret.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/libs/gamecode/test/test-callret.c b/libs/gamecode/test/test-callret.c index 9bf96fa54..5fd48d2c7 100644 --- a/libs/gamecode/test/test-callret.c +++ b/libs/gamecode/test/test-callret.c @@ -136,7 +136,7 @@ static dstatement_t call32_statements[] = { }; static pr_ivec4_t callchain_init[32] = { - { 0, 2, 3, 0 }, + { 0, 2, 3, 4 }, { DB, DB, DB, DB }, }; @@ -152,17 +152,21 @@ static dstatement_t callchain_statements[] = { { OP_LEA_C, STK, -4, STK }, // reserve 4 words on the stack { OP_WITH, 2, 0, 2 }, // put locals into reg 2 { OP(0, 0, 2, OP_CALL_B), 2, 0, 0 }, + { OP(0, 0, 2, OP_CALL_B), 2, 0, 1 }, { OP(2, 0, 0, OP_RETURN), 0, 0, 0 }, [64]= { OP_LEA_C, STK, -4, STK }, // reserve 4 words on the stack { OP_WITH, 2, 0, 2 }, // put locals into reg 2 { OP(0, 0, 2, OP_LEA_A), 42, 0, 0 }, // init value { OP(2, 0, 0, OP_RETURN), 0, 0, 0 }, // return value +[96]= + { OP_RETURN, 0, 0, -1 } // void return }; static bfunction_t callret_functions[] = { { .first_statement = 32 }, { .first_statement = 64 }, + { .first_statement = 96 }, }; test_t tests[] = { From e9af5491956a078039bfb3a7a52af176046ee89d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 18:51:50 +0900 Subject: [PATCH 132/360] [gamecode] Fix some goofs in the callchain test They made it difficult to tell when I got things working :P --- libs/gamecode/test/test-callret.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/gamecode/test/test-callret.c b/libs/gamecode/test/test-callret.c index 5fd48d2c7..d90b95efa 100644 --- a/libs/gamecode/test/test-callret.c +++ b/libs/gamecode/test/test-callret.c @@ -141,7 +141,7 @@ static pr_ivec4_t callchain_init[32] = { }; static pr_ivec4_t callchain_expect[32] = { - { 0, 2, 3, 0 }, + { 0, 2, 3, 4 }, { 42, DB, DB, DB }, }; @@ -152,7 +152,7 @@ static dstatement_t callchain_statements[] = { { OP_LEA_C, STK, -4, STK }, // reserve 4 words on the stack { OP_WITH, 2, 0, 2 }, // put locals into reg 2 { OP(0, 0, 2, OP_CALL_B), 2, 0, 0 }, - { OP(0, 0, 2, OP_CALL_B), 2, 0, 1 }, + { OP(0, 0, 2, OP_CALL_B), 3, 0, 1 }, { OP(2, 0, 0, OP_RETURN), 0, 0, 0 }, [64]= { OP_LEA_C, STK, -4, STK }, // reserve 4 words on the stack From 9348f7b89ca30bc7441ad8c5d19b53ebd7d7a51b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 17 Jan 2022 19:12:28 +0900 Subject: [PATCH 133/360] [gamecode] Preserve the return pointer across calls This required delaying the setting of the return pointer by call until after the current pointer had been saved, and thus passing the desired pointer into PR_CallFunction (which does have some advantages for C functions calling progs functions, but some dangers too (should ensure a 128 byte (32 word) buffer when calling untrusted code (which is any, really)). --- include/QF/progs.h | 5 ++++- libs/gamecode/pr_exec.c | 15 ++++++++++----- libs/ruamoko/rua_obj.c | 12 ++++++------ 3 files changed, 20 insertions(+), 12 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index d2a923743..634eb38a0 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -175,10 +175,12 @@ void PR_ExecuteProgram (progs_t *pr, func_t fnum); execute upon return of control to PR_ExecuteProgram(). \param pr pointer to ::progs_t VM struct \param fnum number of the function to call + \param return_ptr pointer to location in which return values will be + written \return true if \p fnum was a progs function, false if \p fnum was a builtin */ -int PR_CallFunction (progs_t *pr, func_t fnum); +int PR_CallFunction (progs_t *pr, func_t fnum, pr_type_t *return_ptr); ///@} @@ -1806,6 +1808,7 @@ typedef struct { pr_uint_t stack_ptr; ///< data stack on entry to function bfunction_t *func; ///< Calling function. strref_t *tstr; ///< Linked list of temporary strings. + pr_type_t *return_ptr; ///< Saved return address } prstack_t; struct progs_s { diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 90296c153..a8585fc2b 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -149,6 +149,7 @@ PR_PushFrame (progs_t *pr) frame->bases = pr->pr_bases; frame->func = pr->pr_xfunction; frame->tstr = pr->pr_xtstr; + frame->return_ptr = pr->pr_return; pr->pr_xtstr = pr->pr_pushtstr; pr->pr_pushtstr = 0; @@ -180,6 +181,7 @@ PR_PopFrame (progs_t *pr) // up stack frame = pr->pr_stack + --pr->pr_depth; + pr->pr_return = frame->return_ptr; pr->pr_xfunction = frame->func; pr->pr_xstatement = frame->staddr; pr->pr_xtstr = frame->tstr; @@ -419,7 +421,7 @@ error_handler (void *data) } VISIBLE int -PR_CallFunction (progs_t *pr, func_t fnum) +PR_CallFunction (progs_t *pr, func_t fnum, pr_type_t *return_ptr) { bfunction_t *f; @@ -432,10 +434,14 @@ PR_CallFunction (progs_t *pr, func_t fnum) Sys_Printf ("Calling builtin %s @ %p\n", PR_GetString (pr, f->descriptor->name), f->func); } + pr_type_t *saved_return = pr->pr_return; + pr->pr_return = return_ptr; f->func (pr); + pr->pr_return = saved_return; return 0; } else { PR_EnterFunction (pr, f); + pr->pr_return = return_ptr; return 1; } } @@ -1461,7 +1467,7 @@ op_rcall: op_call: pr->pr_xfunction->profile += profile - startprofile; startprofile = profile; - PR_CallFunction (pr, OPA(uint)); + PR_CallFunction (pr, OPA(uint), pr->pr_return); st = pr->pr_statements + pr->pr_xstatement; break; case OP_DONE_v6p: @@ -3154,10 +3160,9 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) function = mm->func_var; pr->pr_argc = 0; // op_c specifies the location for the return value if any - pr->pr_return = op_c; pr->pr_xfunction->profile += profile - startprofile; startprofile = profile; - PR_CallFunction (pr, function); + PR_CallFunction (pr, function, op_c); st = pr->pr_statements + pr->pr_xstatement; break; // 1 1010 @@ -3466,7 +3471,7 @@ PR_ExecuteProgram (progs_t *pr, func_t fnum) } int exitdepth = pr->pr_depth; - if (!PR_CallFunction (pr, fnum)) { + if (!PR_CallFunction (pr, fnum, pr->pr_return)) { // called a builtin instead of progs code goto exit_program; } diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index aab7b4c0f..22a8b98e7 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -1291,7 +1291,7 @@ rua___obj_forward (progs_t *pr) P_PACKED (pr, pr_va_list_t, 3).count = argc; P_PACKED (pr, pr_va_list_t, 3).list = PR_SetPointer (pr, argv); PR_PushTempString (pr, args_block); - PR_CallFunction (pr, imp); + PR_CallFunction (pr, imp, pr->pr_return); return; } //FIXME ditto @@ -1303,7 +1303,7 @@ rua___obj_forward (progs_t *pr) P_POINTER (pr, 1) = PR_SetPointer (pr, err_sel); P_POINTER (pr, 2) = PR_SetPointer (pr, sel); pr->pr_argc = 3; - PR_CallFunction (pr, imp); + PR_CallFunction (pr, imp, pr->pr_return); return; } @@ -1321,7 +1321,7 @@ rua___obj_forward (progs_t *pr) P_POINTER (pr, 1) = PR_SetPointer (pr, err_sel); P_POINTER (pr, 2) = PR_SetTempString (pr, probj->msg->str); pr->pr_argc = 3; - PR_CallFunction (pr, imp); + PR_CallFunction (pr, imp, pr->pr_return); return; } @@ -1437,7 +1437,7 @@ rua_obj_msg_sendv (progs_t *pr) memcpy (&P_INT (pr, 2), params, count * sizeof (pr_type_t) * pr->pr_param_size); } - PR_CallFunction (pr, imp); + PR_CallFunction (pr, imp, pr->pr_return); } static void @@ -1544,7 +1544,7 @@ rua_obj_msgSend (progs_t *pr) PR_GetString (pr, object_get_class_name (probj, self)), PR_GetString (pr, probj->selector_names[_cmd->sel_id])); - PR_CallFunction (pr, imp); + PR_CallFunction (pr, imp, pr->pr_return); } static void @@ -1564,7 +1564,7 @@ rua_obj_msgSend_super (progs_t *pr) } pr->pr_params[0] = pr->pr_real_params[0]; P_POINTER (pr, 0) = super->self; - PR_CallFunction (pr, imp); + PR_CallFunction (pr, imp, pr->pr_return); } static void From 2df64384c1476a6428bb37f9c6be0127cbe88bc7 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 12:11:14 +0900 Subject: [PATCH 134/360] [gamecode] Clean up string_t and pointer_t They are both gone, and pr_pointer_t is now pr_ptr_t (pointer may be a little clearer than ptr, but ptr is consistent with things like intptr, and keeps the type name short). --- include/QF/progs.h | 70 +++++++++++++-------------- include/QF/progs/pr_comp.h | 28 +++++------ include/QF/progs/pr_obj.h | 80 +++++++++++++++---------------- include/QF/progs/pr_type.h | 28 +++++------ include/QF/ruamoko.h | 4 +- libs/console/bi_inputline.c | 2 +- libs/gamecode/pr_debug.c | 22 ++++----- libs/gamecode/pr_exec.c | 82 ++++++++++++++++---------------- libs/gamecode/pr_resolve.c | 6 +-- libs/gamecode/pr_strings.c | 40 ++++++++-------- libs/gamecode/test/head.c | 4 +- libs/gamecode/test/main.c | 4 +- libs/ruamoko/rua_hash.c | 2 +- libs/ruamoko/rua_input.c | 6 +-- libs/ruamoko/rua_obj.c | 36 +++++++------- libs/ruamoko/rua_qfile.c | 2 +- libs/ruamoko/rua_qfs.c | 8 ++-- libs/ruamoko/rua_runtime.c | 2 +- libs/ruamoko/rua_script.c | 2 +- libs/ruamoko/rua_set.c | 48 +++++++++---------- libs/ruamoko/rua_string.c | 2 +- nq/include/sv_progs.h | 16 +++---- qw/include/sv_progs.h | 12 ++--- qw/source/sv_pr_cpqw.c | 2 +- ruamoko/qwaq/builtins/debug.c | 56 +++++++++++----------- ruamoko/qwaq/builtins/main.c | 2 +- ruamoko/qwaq/debugger/debug.h | 6 +-- ruamoko/qwaq/editor/editbuffer.h | 2 +- ruamoko/qwaq/qwaq-input.h | 8 ++-- ruamoko/qwaq/ui/event.h | 4 +- ruamoko/qwaq/ui/textcontext.h | 2 +- tools/qfcc/include/def.h | 2 +- tools/qfcc/include/expr.h | 2 +- tools/qfcc/include/function.h | 6 +-- tools/qfcc/include/obj_file.h | 16 +++---- tools/qfcc/include/qfcc.h | 4 +- tools/qfcc/include/reloc.h | 2 +- tools/qfcc/source/class.c | 4 +- tools/qfcc/source/diagnostic.c | 6 +-- tools/qfcc/source/dump_globals.c | 8 ++-- tools/qfcc/source/dump_lines.c | 2 +- tools/qfcc/source/dump_modules.c | 8 ++-- tools/qfcc/source/expr.c | 8 ++-- tools/qfcc/source/linker.c | 4 +- tools/qfcc/source/obj_file.c | 8 ++-- tools/qfcc/source/obj_type.c | 2 +- tools/qfcc/source/stub.c | 2 +- tools/qfcc/source/switch.c | 2 +- tools/qfcc/source/value.c | 2 +- tools/qfcc/test/test-harness.c | 2 +- 50 files changed, 338 insertions(+), 340 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 634eb38a0..f8c8d42b0 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -265,7 +265,7 @@ int PR_RunPostLoadFuncs (progs_t *pr); */ int PR_Check_Opcodes (progs_t *pr); -void PR_BoundsCheckSize (progs_t *pr, pointer_t addr, unsigned size); +void PR_BoundsCheckSize (progs_t *pr, pr_ptr_t addr, unsigned size); void PR_BoundsCheck (progs_t *pr, int addr, etype_t type); ///@} @@ -336,10 +336,10 @@ void ED_EntityParseFunction (progs_t *pr); */ ///@{ -pr_def_t *PR_SearchDefs (pr_def_t *defs, unsigned num_defs, pointer_t offset) +pr_def_t *PR_SearchDefs (pr_def_t *defs, unsigned num_defs, pr_ptr_t offset) __attribute__((pure)); -pr_def_t *PR_FieldAtOfs (progs_t *pr, pointer_t ofs) __attribute__((pure)); -pr_def_t *PR_GlobalAtOfs (progs_t *pr, pointer_t ofs) __attribute__((pure)); +pr_def_t *PR_FieldAtOfs (progs_t *pr, pr_ptr_t ofs) __attribute__((pure)); +pr_def_t *PR_GlobalAtOfs (progs_t *pr, pr_ptr_t ofs) __attribute__((pure)); pr_def_t *PR_FindField (progs_t *pr, const char *name); pr_def_t *PR_FindGlobal (progs_t *pr, const char *name); @@ -470,7 +470,7 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ \c string \param p pointer to ::progs_t VM struct \param o offset into global data space - \return string_t lvalue + \return pr_string_t lvalue \hideinitializer */ @@ -494,7 +494,7 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ \c void * \param p pointer to ::progs_t VM struct \param o offset into global data space - \return pointer_t lvalue + \return pr_ptr_t lvalue \hideinitializer */ @@ -686,7 +686,7 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ \c string \param p pointer to ::progs_t VM struct \param n parameter number (0-7) - \return string_t lvalue + \return pr_string_t lvalue \hideinitializer */ @@ -710,7 +710,7 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ \c void * \param p pointer to ::progs_t VM struct \param n parameter number (0-7) - \return pointer_t lvalue + \return pr_ptr_t lvalue \hideinitializer */ @@ -891,12 +891,12 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ */ #define R_QUAT(p) (&R_var (p, quat)) -/** Access the VM function return value as a ::string_t (a VM string reference). +/** Access the VM function return value as a ::pr_string_t (a VM string reference). \par QC type: \c string \param p pointer to ::progs_t VM struct - \return ::string_t lvalue + \return ::pr_string_t lvalue \hideinitializer */ @@ -913,12 +913,12 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ */ #define R_FUNCTION(p) R_var (p, func) -/** Access the VM function return value as a ::pointer_t (a VM "pointer") +/** Access the VM function return value as a ::pr_ptr_t (a VM "pointer") \par QC type: \c void * \param p pointer to ::progs_t VM struct - \return ::pointer_t lvalue + \return ::pr_ptr_t lvalue \hideinitializer */ @@ -1091,7 +1091,7 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ \c string \param e pointer to the entity \param o field offset into entity data space - \return string_t lvalue + \return pr_string_t lvalue \hideinitializer */ @@ -1115,7 +1115,7 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ \c void * \param e pointer to the entity \param o field offset into entity data space - \return pointer_t lvalue + \return pr_ptr_t lvalue \hideinitializer */ @@ -1282,28 +1282,28 @@ int PR_LoadStrings (progs_t *pr); \param num string index to be validated \return true if the index is valid, false otherwise */ -qboolean PR_StringValid (progs_t *pr, string_t num) __attribute__((pure)); +qboolean PR_StringValid (progs_t *pr, pr_string_t num) __attribute__((pure)); /** Check if a string is valid and mutable. \param pr pointer to ::progs_t VM struct \param num string index to be checked \return true if the string is valid and mutable, false otherwise */ -qboolean PR_StringMutable (progs_t *pr, string_t num) __attribute__((pure)); +qboolean PR_StringMutable (progs_t *pr, pr_string_t num) __attribute__((pure)); /** Convert a string index to a C string. \param pr pointer to ::progs_t VM struct \param num string index to be converted \return C pointer to the string. */ -const char *PR_GetString(progs_t *pr, string_t num) __attribute__((pure)); +const char *PR_GetString(progs_t *pr, pr_string_t num) __attribute__((pure)); /** Retrieve the dstring_t associated with a mutable string. \param pr pointer to ::progs_t VM struct \param num string index of the mutable string \return the dstring implementing the mutable string */ -struct dstring_s *PR_GetMutableString(progs_t *pr, string_t num) __attribute__((pure)); +struct dstring_s *PR_GetMutableString(progs_t *pr, pr_string_t num) __attribute__((pure)); /** Make a permanent progs string from the given C string. Will not create a duplicate permanent string (temporary and mutable strings are not checked). @@ -1311,7 +1311,7 @@ struct dstring_s *PR_GetMutableString(progs_t *pr, string_t num) __attribute__(( \param s C string to be made into a permanent progs string \return string index of the progs string */ -string_t PR_SetString(progs_t *pr, const char *s); +pr_string_t PR_SetString(progs_t *pr, const char *s); /** Get the progs string if it exists. Only static strings are searched. @@ -1320,7 +1320,7 @@ string_t PR_SetString(progs_t *pr, const char *s); \return string index of the progs string if it exists, otherwise 0 (ambiguous with ""). */ -string_t PR_FindString(progs_t *pr, const char *s); +pr_string_t PR_FindString(progs_t *pr, const char *s); /** Make a temporary progs string that will survive across function returns. Will not duplicate a permanent string. If a new progs string is created, @@ -1330,7 +1330,7 @@ string_t PR_FindString(progs_t *pr, const char *s); \param s C string to be returned to the progs code \return string index of the progs string */ -string_t PR_SetReturnString(progs_t *pr, const char *s); +pr_string_t PR_SetReturnString(progs_t *pr, const char *s); /** Make a temporary progs string that will be freed when the current progs stack frame is exited. Will not duplicate a permantent string. @@ -1338,7 +1338,7 @@ string_t PR_SetReturnString(progs_t *pr, const char *s); \param s C string \return string index of the progs string */ -string_t PR_SetTempString(progs_t *pr, const char *s); +pr_string_t PR_SetTempString(progs_t *pr, const char *s); /** Make a temporary memory block that will be freed when the current progs stack frame is exited. The contents may be anything and a new block is @@ -1350,7 +1350,7 @@ string_t PR_SetTempString(progs_t *pr, const char *s); \param size size of block in bytes \return string index of the block */ -string_t PR_AllocTempBlock (progs_t *pr, size_t size); +pr_string_t PR_AllocTempBlock (progs_t *pr, size_t size); /** Push a temporary string to the callee stack frame @@ -1361,7 +1361,7 @@ string_t PR_AllocTempBlock (progs_t *pr, size_t size); \param pr pointer to ::progs_t VM struct \param num string index of the temp string */ -void PR_PushTempString (progs_t *pr, string_t num); +void PR_PushTempString (progs_t *pr, pr_string_t num); /** Make a temporary progs string that is the concatenation of two C strings. \param pr pointer to ::progs_t VM struct @@ -1370,19 +1370,19 @@ void PR_PushTempString (progs_t *pr, string_t num); \return string index of the progs string that represents the concatenation of strings a and b */ -string_t PR_CatStrings (progs_t *pr, const char *a, const char *b); +pr_string_t PR_CatStrings (progs_t *pr, const char *a, const char *b); /** Convert a mutable string to a temporary string. \param pr pointer to ::progs_t VM struct \param str string index of the mutable string to be converted */ -void PR_MakeTempString(progs_t *pr, string_t str); +void PR_MakeTempString(progs_t *pr, pr_string_t str); /** Create a new mutable string. \param pr pointer to ::progs_t VM struct \return string index of the newly created mutable string */ -string_t PR_NewMutableString (progs_t *pr); +pr_string_t PR_NewMutableString (progs_t *pr); /** Make a dynamic progs string from the given C string. Will not create a duplicate permanent string (temporary, dynamic and mutable strings are @@ -1391,7 +1391,7 @@ string_t PR_NewMutableString (progs_t *pr); \param s C string to be made into a permanent progs string \return string index of the progs string */ -string_t PR_SetDynamicString (progs_t *pr, const char *s); +pr_string_t PR_SetDynamicString (progs_t *pr, const char *s); /** Convert an ephemeral string to a dynamic string. @@ -1403,13 +1403,13 @@ string_t PR_SetDynamicString (progs_t *pr, const char *s); \param str The string to be "held" (made non-ephemeral). Safe to call on any valid string, but affects only ephemeral strings. */ -void PR_HoldString (progs_t *pr, string_t str); +void PR_HoldString (progs_t *pr, pr_string_t str); /** Destroy a mutable, dynamic or temporary string. \param pr pointer to ::progs_t VM struct \param str string index of the string to be destroyed */ -void PR_FreeString (progs_t *pr, string_t str); +void PR_FreeString (progs_t *pr, pr_string_t str); /** Free all the temporary strings allocated in the current stack frame. \param pr pointer to ::progs_t VM struct @@ -1765,7 +1765,7 @@ pr_uint_t PR_FindSourceLineAddr (progs_t *pr, const char *file, pr_uint_t line) const char *PR_Get_Source_File (progs_t *pr, pr_lineno_t *lineno) __attribute__((pure)); const char *PR_Get_Source_Line (progs_t *pr, pr_uint_t addr); pr_def_t *PR_Get_Param_Def (progs_t *pr, dfunction_t *func, unsigned parm) __attribute__((pure)); -pr_def_t *PR_Get_Local_Def (progs_t *pr, pointer_t *offs) __attribute__((pure)); +pr_def_t *PR_Get_Local_Def (progs_t *pr, pr_ptr_t *offs) __attribute__((pure)); void PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents); void PR_DumpState (progs_t *pr); void PR_StackTrace (progs_t *pr); @@ -1935,7 +1935,7 @@ struct progs_s { /// stack. ///@{ pr_type_t *stack; - pointer_t stack_bottom; + pr_ptr_t stack_bottom; int stack_size; ///< set by user ///@} @@ -1970,7 +1970,7 @@ struct progs_s { double *dtime; ///< required for OP_STATE d float *ftime; ///< required for OP_STATE f pr_uint_t *self; ///< required for OP_STATE - pointer_t *stack; ///< required for OP_(PUSH|POP)* + pr_ptr_t *stack; ///< required for OP_(PUSH|POP)* } globals; struct { pr_int_t nextthink; ///< required for OP_STATE @@ -1991,7 +1991,7 @@ struct progs_s { \return C pointer represented by the parameter. 0 offset -> NULL */ static inline pr_type_t * -PR_GetPointer (const progs_t *pr, pointer_t o) +PR_GetPointer (const progs_t *pr, pr_ptr_t o) { return o ? pr->pr_globals + o : 0; } @@ -2001,7 +2001,7 @@ PR_GetPointer (const progs_t *pr, pointer_t o) \param p C pointer to be converted. \return Progs offset/pointer represented by \c p. NULL -> 0 offset */ -static inline pointer_t +static inline pr_ptr_t PR_SetPointer (const progs_t *pr, const void *p) { return p ? (const pr_type_t *) p - pr->pr_globals : 0; diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 2b5c0ad79..7b097cda1 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -33,9 +33,7 @@ typedef int64_t pr_long_t; typedef uint64_t pr_ulong_t; typedef pr_uint_t func_t; typedef pr_int_t pr_string_t; -typedef pr_string_t string_t;//FIXME -typedef pr_uint_t pr_pointer_t; -typedef pr_pointer_t pointer_t;//FIXME +typedef pr_uint_t pr_ptr_t; #define PR_VEC_TYPE(t,n,s) \ typedef t n __attribute__ ((vector_size (s*sizeof (t)))) @@ -489,25 +487,25 @@ typedef struct ddef_s { pr_ushort_t type; // if DEF_SAVEGLOBAL bit is set // the variable needs to be saved in savegames pr_ushort_t ofs; - string_t name; + pr_string_t name; } ddef_t; typedef struct xdef_s { - pointer_t type; ///< pointer to type definition - pointer_t ofs; ///< 32-bit version of ddef_t.ofs + pr_ptr_t type; ///< pointer to type definition + pr_ptr_t ofs; ///< 32-bit version of ddef_t.ofs } xdef_t; typedef struct pr_xdefs_s { - pointer_t xdefs; + pr_ptr_t xdefs; pr_int_t num_xdefs; } pr_xdefs_t; typedef struct pr_def_s { pr_ushort_t type; pr_ushort_t size; ///< may not be correct - pointer_t ofs; - string_t name; - pointer_t type_encoding; + pr_ptr_t ofs; + pr_string_t name; + pr_ptr_t type_encoding; } pr_def_t; typedef struct dparmsize_s { @@ -526,8 +524,8 @@ typedef struct dfunction_s { pr_uint_t profile; // runtime - string_t name; // source function name - string_t file; // source file defined in + pr_string_t name; // source function name + pr_string_t file; // source file defined in pr_int_t numparms; // -ve is varargs (1s comp of real count) dparmsize_t parm_size[MAX_PARMS]; @@ -535,19 +533,19 @@ typedef struct dfunction_s { typedef union pr_type_u { float float_var; - string_t string_var; + pr_string_t string_var; func_t func_var; pr_uint_t entity_var; float vector_var; // really [3], but this structure must be 32 bits float quat_var; // really [4], but this structure must be 32 bits pr_int_t integer_var; - pointer_t pointer_var; + pr_ptr_t pointer_var; pr_uint_t uinteger_var; } pr_type_t; typedef struct pr_va_list_s { pr_int_t count; - pointer_t list; // pr_type_t + pr_ptr_t list; // pr_type_t } pr_va_list_t; #define PROG_VERSION_ENCODE(a,b,c) \ diff --git a/include/QF/progs/pr_obj.h b/include/QF/progs/pr_obj.h index ea8f6a052..00f493469 100644 --- a/include/QF/progs/pr_obj.h +++ b/include/QF/progs/pr_obj.h @@ -77,58 +77,58 @@ | (num) << (PR_BITS_PER_INT / 2)) typedef struct pr_sel_s { - pointer_t sel_id; - string_t sel_types; + pr_ptr_t sel_id; + pr_string_t sel_types; } pr_sel_t; typedef struct pr_id_s { - pointer_t class_pointer; // pr_class_t + pr_ptr_t class_pointer; // pr_class_t } pr_id_t; typedef struct pr_class_s { - pointer_t class_pointer; // pr_class_t - pointer_t super_class; // pr_class_t - string_t name; + pr_ptr_t class_pointer; // pr_class_t + pr_ptr_t super_class; // pr_class_t + pr_string_t name; pr_int_t version; pr_uint_t info; pr_int_t instance_size; - pointer_t ivars; // pr_ivar_list_t - pointer_t methods; // pr_method_list_t - pointer_t dtable; // resource index - pointer_t subclass_list; // pr_class_t - pointer_t sibling_class; // pr_class_t - pointer_t protocols; // pr_protocol_list_t - pointer_t gc_object_type; + pr_ptr_t ivars; // pr_ivar_list_t + pr_ptr_t methods; // pr_method_list_t + pr_ptr_t dtable; // resource index + pr_ptr_t subclass_list; // pr_class_t + pr_ptr_t sibling_class; // pr_class_t + pr_ptr_t protocols; // pr_protocol_list_t + pr_ptr_t gc_object_type; } pr_class_t; typedef struct pr_protocol_s { - pointer_t class_pointer; // pr_class_t - string_t protocol_name; - pointer_t protocol_list; // pr_protocol_list_t - pointer_t instance_methods; // pr_method_description_list_t - pointer_t class_methods; // pr_method_description_list_t + pr_ptr_t class_pointer; // pr_class_t + pr_string_t protocol_name; + pr_ptr_t protocol_list; // pr_protocol_list_t + pr_ptr_t instance_methods; // pr_method_description_list_t + pr_ptr_t class_methods; // pr_method_description_list_t } pr_protocol_t; typedef struct pr_category_s { - string_t category_name; - string_t class_name; - pointer_t instance_methods; // pr_method_list_t - pointer_t class_methods; // pr_method_list_t - pointer_t protocols; // pr_protocol_list_t + pr_string_t category_name; + pr_string_t class_name; + pr_ptr_t instance_methods; // pr_method_list_t + pr_ptr_t class_methods; // pr_method_list_t + pr_ptr_t protocols; // pr_protocol_list_t } pr_category_t; typedef struct pr_protocol_list_s { - pointer_t next; + pr_ptr_t next; pr_int_t count; - pointer_t list[1]; // pr_protocol_t + pr_ptr_t list[1]; // pr_protocol_t } pr_protocol_list_t; typedef struct pr_method_list_s { - pointer_t method_next; + pr_ptr_t method_next; pr_int_t method_count; struct pr_method_s { - pointer_t method_name; // pr_sel_t - string_t method_types; + pr_ptr_t method_name; // pr_sel_t + pr_string_t method_types; func_t method_imp; // typedef id (id, SEL, ...) IMP } method_list[1]; } pr_method_list_t; @@ -137,8 +137,8 @@ typedef struct pr_method_s pr_method_t; typedef struct pr_method_description_list_s { pr_int_t count; struct pr_method_description_s { - pointer_t name; // pr_sel_t - string_t types; + pr_ptr_t name; // pr_sel_t + pr_string_t types; } list[1]; } pr_method_description_list_t; typedef struct pr_method_description_s pr_method_description_t; @@ -146,8 +146,8 @@ typedef struct pr_method_description_s pr_method_description_t; typedef struct pr_ivar_list_s { pr_int_t ivar_count; struct pr_ivar_s { - string_t ivar_name; - string_t ivar_type; + pr_string_t ivar_name; + pr_string_t ivar_type; pr_int_t ivar_offset; } ivar_list[1]; } pr_ivar_list_t; @@ -157,16 +157,16 @@ typedef struct pr_static_instances_s { // one per staticly instanced class per module (eg, 3 instances of Object // will produce one of these structs with 3 pointers to those instances in // instances[] - string_t class_name; - pointer_t instances[1]; // null terminated array of pr_id_t + pr_string_t class_name; + pr_ptr_t instances[1]; // null terminated array of pr_id_t } pr_static_instances_t; typedef struct pr_symtab_s { pr_int_t sel_ref_cnt; - pointer_t refs; // pr_sel_t + pr_ptr_t refs; // pr_sel_t pr_int_t cls_def_cnt; pr_int_t cat_def_cnt; - pointer_t defs[1]; // variable array of cls_def_cnt class + pr_ptr_t defs[1]; // variable array of cls_def_cnt class // pointers then cat_def_cnt category // pointers followed by a null terminated // array of pr_static_instances (not yet @@ -176,13 +176,13 @@ typedef struct pr_symtab_s { typedef struct pr_module_s { pr_int_t version; pr_int_t size; - string_t name; - pointer_t symtab; // pr_symtab_t + pr_string_t name; + pr_ptr_t symtab; // pr_symtab_t } pr_module_t; typedef struct pr_super_s { - pointer_t self; - pointer_t class; + pr_ptr_t self; + pr_ptr_t class; } pr_super_t; #endif//__QF_pr_obj_h diff --git a/include/QF/progs/pr_type.h b/include/QF/progs/pr_type.h index 04a3266f6..328b2ff3e 100644 --- a/include/QF/progs/pr_type.h +++ b/include/QF/progs/pr_type.h @@ -34,7 +34,7 @@ /** \defgroup qfcc_qfo_type Object file type encoding \ingroup progs - All \c pointer_t \c type fields are pointers within the type qfo_space. + All \c pr_ptr_t \c type fields are pointers within the type qfo_space. */ ///@{ @@ -52,43 +52,43 @@ typedef enum { typedef struct qfot_alias_s { etype_t type; ///< type at end of alias chain - pointer_t aux_type; ///< referenced type: stripped of aliases - pointer_t full_type; ///< includes full alias info - string_t name; ///< alias name, may be null + pr_ptr_t aux_type; ///< referenced type: stripped of aliases + pr_ptr_t full_type; ///< includes full alias info + pr_string_t name; ///< alias name, may be null } qfot_alias_t; typedef struct qfot_fldptr_s { etype_t type; ///< ev_field or ev_pointer - pointer_t aux_type; ///< referenced type + pr_ptr_t aux_type; ///< referenced type } qfot_fldptr_t; typedef struct qfot_func_s { etype_t type; ///< always ev_func - pointer_t return_type; ///< return type of the function + pr_ptr_t return_type; ///< return type of the function pr_int_t num_params; ///< ones compliment count of the ///< parameters. -ve values indicate the ///< number of real parameters before the ///< ellipsis - pointer_t param_types[1]; ///< variable length list of parameter + pr_ptr_t param_types[1]; ///< variable length list of parameter ///< types } qfot_func_t; typedef struct qfot_var_s { - pointer_t type; ///< type of field or self reference for + pr_ptr_t type; ///< type of field or self reference for ///< enum - string_t name; ///< name of field/enumerator + pr_string_t name; ///< name of field/enumerator pr_int_t offset; ///< value for enum, 0 for union } qfot_var_t; typedef struct qfot_struct_s { - string_t tag; ///< struct/union/enum tag + pr_string_t tag; ///< struct/union/enum tag pr_int_t num_fields; ///< number of fields/enumerators qfot_var_t fields[1]; ///< variable length list of ///< fields/enumerators } qfot_struct_t; typedef struct qfot_array_s { - pointer_t type; ///< element type + pr_ptr_t type; ///< element type pr_int_t base; ///< start index of array pr_int_t size; ///< number of elements in array } qfot_array_t; @@ -103,20 +103,20 @@ typedef struct qfot_array_s { typedef struct qfot_type_s { ty_meta_e meta; ///< meta type pr_uint_t size; ///< total word size of this encoding - string_t encoding; ///< Objective-QC encoding + pr_string_t encoding; ///< Objective-QC encoding union { etype_t type; ///< ty_basic: etype_t qfot_fldptr_t fldptr; ///< ty_basic, ev_pointer/ev_field qfot_func_t func; ///< ty_basic, ev_func qfot_struct_t strct; ///< ty_struct/ty_union/ty_enum qfot_array_t array; ///< ty_array - string_t class; ///< ty_class + pr_string_t class; ///< ty_class qfot_alias_t alias; ///< ty_alias }; } qfot_type_t; typedef struct qfot_type_encodings_s { - pointer_t types; + pr_ptr_t types; pr_uint_t size; } qfot_type_encodings_t; diff --git a/include/QF/ruamoko.h b/include/QF/ruamoko.h index b6f82ff31..8ee071632 100644 --- a/include/QF/ruamoko.h +++ b/include/QF/ruamoko.h @@ -38,8 +38,8 @@ struct cbuf_s; void RUA_Init (struct progs_s *pr, int secure); void RUA_Cbuf_SetCbuf (struct progs_s *pr, struct cbuf_s *cbuf); -func_t RUA_Obj_msg_lookup (struct progs_s *pr, pointer_t _self, - pointer_t __cmd); +func_t RUA_Obj_msg_lookup (struct progs_s *pr, pr_ptr_t _self, + pr_ptr_t __cmd); void RUA_Game_Init (struct progs_s *pr, int secure); diff --git a/libs/console/bi_inputline.c b/libs/console/bi_inputline.c index 76e9b676c..1c63a69a7 100644 --- a/libs/console/bi_inputline.c +++ b/libs/console/bi_inputline.c @@ -50,7 +50,7 @@ typedef struct il_data_s { inputline_t *line; progs_t *pr; func_t enter; // enter key callback - pointer_t data[2]; // allow two data params for the callback + pr_ptr_t data[2]; // allow two data params for the callback int method; // true if method rather than function } il_data_t; diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index e4268eef5..4b4b23d05 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -557,7 +557,7 @@ PR_DebugSetSym (progs_t *pr, pr_debug_header_t *debug) } qfot_type_encodings_t *encodings = 0; - pointer_t type_encodings = 0; + pr_ptr_t type_encodings = 0; res->type_encodings_def = PR_FindGlobal (pr, ".type_encodings"); if (res->type_encodings_def) { encodings = &G_STRUCT (pr, qfot_type_encodings_t, @@ -581,7 +581,7 @@ PR_DebugSetSym (progs_t *pr, pr_debug_header_t *debug) } } - string_t compunit_str = PR_FindString (pr, ".compile_unit"); + pr_string_t compunit_str = PR_FindString (pr, ".compile_unit"); for (pr_uint_t i = 0; i < debug->num_debug_defs; i++) { pr_def_t *def = &res->debug_defs[i]; if (type_encodings) { @@ -595,7 +595,7 @@ PR_DebugSetSym (progs_t *pr, pr_debug_header_t *debug) if (encodings) { qfot_type_t *type; - for (pointer_t type_ptr = 4; type_ptr < encodings->size; + for (pr_ptr_t type_ptr = 4; type_ptr < encodings->size; type_ptr += type->size) { type = &G_STRUCT (pr, qfot_type_t, type_encodings + type_ptr); if (type->meta == ty_basic @@ -968,12 +968,12 @@ get_type (prdeb_resources_t *res, int typeptr) } pr_def_t * -PR_Get_Local_Def (progs_t *pr, pointer_t *offset) +PR_Get_Local_Def (progs_t *pr, pr_ptr_t *offset) { prdeb_resources_t *res = pr->pr_debug_resources; dfunction_t *func; pr_auxfunction_t *aux_func; - pointer_t offs = *offset; + pr_ptr_t offs = *offset; pr_def_t *def; if (!pr->pr_xfunction) @@ -1102,7 +1102,7 @@ value_string (pr_debug_data_t *data, qfot_type_t *type, pr_type_t *value) } static pr_def_t * -pr_debug_find_def (progs_t *pr, pointer_t *ofs) +pr_debug_find_def (progs_t *pr, pr_ptr_t *ofs) { prdeb_resources_t *res = pr->pr_debug_resources; pr_def_t *def = 0; @@ -1123,7 +1123,7 @@ pr_debug_find_def (progs_t *pr, pointer_t *ofs) } static const char * -global_string (pr_debug_data_t *data, pointer_t offset, qfot_type_t *type, +global_string (pr_debug_data_t *data, pr_ptr_t offset, qfot_type_t *type, int contents) { progs_t *pr = data->pr; @@ -1132,7 +1132,7 @@ global_string (pr_debug_data_t *data, pointer_t offset, qfot_type_t *type, pr_def_t *def = NULL; qfot_type_t dummy_type = { }; const char *name = 0; - pointer_t offs = offset; + pr_ptr_t offs = offset; dstring_clearstr (dstr); @@ -1198,7 +1198,7 @@ pr_debug_string_view (qfot_type_t *type, pr_type_t *value, void *_data) { __auto_type data = (pr_debug_data_t *) _data; dstring_t *dstr = data->dstr; - string_t string = value->string_var; + pr_string_t string = value->string_var; if (PR_StringValid (data->pr, string)) { const char *str = PR_GetString (data->pr, string); @@ -1316,8 +1316,8 @@ pr_debug_pointer_view (qfot_type_t *type, pr_type_t *value, void *_data) __auto_type data = (pr_debug_data_t *) _data; progs_t *pr = data->pr; dstring_t *dstr = data->dstr; - pointer_t offset = value->integer_var; - pointer_t offs = offset; + pr_ptr_t offset = value->integer_var; + pr_ptr_t offs = offset; pr_def_t *def = 0; def = pr_debug_find_def (pr, &offs); diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index a8585fc2b..53964982f 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -220,7 +220,7 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) { pr_int_t i; pr_type_t *dstParams[MAX_PARMS]; - pointer_t paramofs = 0; + pr_ptr_t paramofs = 0; if (pr->pr_trace && !pr->debug_handler) { Sys_Printf ("Entering function %s\n", @@ -338,9 +338,9 @@ PR_LeaveFunction (progs_t *pr, int to_engine) } VISIBLE void -PR_BoundsCheckSize (progs_t *pr, pointer_t addr, unsigned size) +PR_BoundsCheckSize (progs_t *pr, pr_ptr_t addr, unsigned size) { - if (addr < (pointer_t) (pr->pr_return - pr->pr_globals)) + if (addr < (pr_ptr_t) (pr->pr_return - pr->pr_globals)) PR_RunError (pr, "null pointer access"); if (addr >= pr->globals_size || size > (unsigned) (pr->globals_size - addr)) @@ -447,7 +447,7 @@ PR_CallFunction (progs_t *pr, func_t fnum, pr_type_t *return_ptr) } static void -check_stack_pointer (progs_t *pr, pointer_t stack, int size) +check_stack_pointer (progs_t *pr, pr_ptr_t stack, int size) { if (stack < pr->stack_bottom) { PR_RunError (pr, "Progs stack overflow"); @@ -1070,7 +1070,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_PUSH_I_v6p: case OP_PUSH_P_v6p: { - pointer_t stack = *pr->globals.stack - 1; + pr_ptr_t stack = *pr->globals.stack - 1; pr_type_t *stk = pr->pr_globals + stack; if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 1); @@ -1081,7 +1081,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_PUSH_V_v6p: { - pointer_t stack = *pr->globals.stack - 3; + pr_ptr_t stack = *pr->globals.stack - 3; pr_type_t *stk = pr->pr_globals + stack; if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 3); @@ -1092,7 +1092,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_PUSH_Q_v6p: { - pointer_t stack = *pr->globals.stack - 4; + pr_ptr_t stack = *pr->globals.stack - 4; pr_type_t *stk = pr->pr_globals + stack; if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 4); @@ -1110,7 +1110,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_PUSHB_I_v6p: case OP_PUSHB_P_v6p: { - pointer_t stack = *pr->globals.stack - 1; + pr_ptr_t stack = *pr->globals.stack - 1; pr_type_t *stk = pr->pr_globals + stack; pointer = OPA(int) + OPB(int); @@ -1127,7 +1127,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_PUSHB_V_v6p: { - pointer_t stack = *pr->globals.stack - 3; + pr_ptr_t stack = *pr->globals.stack - 3; pr_type_t *stk = pr->pr_globals + stack; pointer = OPA(int) + OPB(int); @@ -1144,7 +1144,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_PUSHB_Q_v6p: { - pointer_t stack = *pr->globals.stack - 4; + pr_ptr_t stack = *pr->globals.stack - 4; pr_type_t *stk = pr->pr_globals + stack; pointer = OPA(int) + OPB(int); @@ -1168,7 +1168,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_PUSHBI_I_v6p: case OP_PUSHBI_P_v6p: { - pointer_t stack = *pr->globals.stack - 1; + pr_ptr_t stack = *pr->globals.stack - 1; pr_type_t *stk = pr->pr_globals + stack; pointer = OPA(int) + st->b; @@ -1185,7 +1185,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_PUSHBI_V_v6p: { - pointer_t stack = *pr->globals.stack - 3; + pr_ptr_t stack = *pr->globals.stack - 3; pr_type_t *stk = pr->pr_globals + stack; pointer = OPA(int) + st->b; @@ -1202,7 +1202,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_PUSHBI_Q_v6p: { - pointer_t stack = *pr->globals.stack - 4; + pr_ptr_t stack = *pr->globals.stack - 4; pr_type_t *stk = pr->pr_globals + stack; pointer = OPA(int) + st->b; @@ -1226,7 +1226,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_POP_I_v6p: case OP_POP_P_v6p: { - pointer_t stack = *pr->globals.stack; + pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 1); @@ -1237,7 +1237,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_POP_V_v6p: { - pointer_t stack = *pr->globals.stack; + pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 3); @@ -1248,7 +1248,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_POP_Q_v6p: { - pointer_t stack = *pr->globals.stack; + pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 4); @@ -1266,7 +1266,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_POPB_I_v6p: case OP_POPB_P_v6p: { - pointer_t stack = *pr->globals.stack; + pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; pointer = OPA(int) + OPB(int); @@ -1283,7 +1283,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_POPB_V_v6p: { - pointer_t stack = *pr->globals.stack; + pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; pointer = OPA(int) + OPB(int); @@ -1300,7 +1300,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_POPB_Q_v6p: { - pointer_t stack = *pr->globals.stack; + pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; pointer = OPA(int) + OPB(int); @@ -1324,7 +1324,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_POPBI_I_v6p: case OP_POPBI_P_v6p: { - pointer_t stack = *pr->globals.stack; + pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; pointer = OPA(int) + st->b; @@ -1341,7 +1341,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_POPBI_V_v6p: { - pointer_t stack = *pr->globals.stack; + pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; pointer = OPA(int) + st->b; @@ -1358,7 +1358,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_POPBI_Q_v6p: { - pointer_t stack = *pr->globals.stack; + pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; pointer = OPA(int) + st->b; @@ -1670,16 +1670,16 @@ op_call: break; case OP_MEMSETP_v6p: if (pr_boundscheck->int_val) { - PR_BoundsCheckSize (pr, OPC(pointer), OPB(int)); + PR_BoundsCheckSize (pr, OPC(ptr), OPB(int)); } - pr_memset (pr->pr_globals + OPC(pointer), OPA(int), + pr_memset (pr->pr_globals + OPC(ptr), OPA(int), OPB(int)); break; case OP_MEMSETPI_v6p: if (pr_boundscheck->int_val) { - PR_BoundsCheckSize (pr, OPC(pointer), st->b); + PR_BoundsCheckSize (pr, OPC(ptr), st->b); } - pr_memset (pr->pr_globals + OPC(pointer), OPA(int), + pr_memset (pr->pr_globals + OPC(ptr), OPA(int), st->b); break; case OP_GE_D_v6p: @@ -1754,7 +1754,7 @@ pr_address_mode (progs_t *pr, const dstatement_t *st, int mm_ind) { pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, B); - pointer_t mm_offs = 0; + pr_ptr_t mm_offs = 0; switch (mm_ind) { case 0: @@ -1775,7 +1775,7 @@ pr_address_mode (progs_t *pr, const dstatement_t *st, int mm_ind) break; case 4: // entity.field (equivalent to OP_LOAD_t_v6p) - pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; + pr_ptr_t edict_area = pr->pr_edict_area - pr->pr_globals; mm_offs = edict_area + OPA(uint) + OPB(uint); break; } @@ -1787,7 +1787,7 @@ pr_return_mode (progs_t *pr, const dstatement_t *st, int mm_ind) { pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, B); - pointer_t mm_offs = 0; + pr_ptr_t mm_offs = 0; switch (mm_ind) { case 0: @@ -1808,7 +1808,7 @@ pr_return_mode (progs_t *pr, const dstatement_t *st, int mm_ind) break; case 4: // entity.field (equivalent to OP_LOAD_t_v6p) - pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; + pr_ptr_t edict_area = pr->pr_edict_area - pr->pr_globals; mm_offs = edict_area + OPA(uint) + OPB(uint); break; } @@ -1820,7 +1820,7 @@ pr_call_mode (progs_t *pr, const dstatement_t *st, int mm_ind) { pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, B); - pointer_t mm_offs = 0; + pr_ptr_t mm_offs = 0; switch (mm_ind) { case 1: @@ -1837,19 +1837,19 @@ pr_call_mode (progs_t *pr, const dstatement_t *st, int mm_ind) break; case 4: // entity.field (equivalent to OP_LOAD_t_v6p) - pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; + pr_ptr_t edict_area = pr->pr_edict_area - pr->pr_globals; mm_offs = edict_area + OPA(uint) + OPB(uint); break; } return pr->pr_globals + mm_offs; } -static pr_pointer_t __attribute__((pure)) +static pr_ptr_t __attribute__((pure)) pr_jump_mode (progs_t *pr, const dstatement_t *st, int jump_ind) { pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, B); - pointer_t jump_offs = pr->pr_xstatement; + pr_ptr_t jump_offs = pr->pr_xstatement; switch (jump_ind) { case 0: @@ -1879,7 +1879,7 @@ static pr_type_t * pr_stack_push (progs_t *pr) { // keep the stack 16-byte aligned - pointer_t stack = *pr->globals.stack - 4; + pr_ptr_t stack = *pr->globals.stack - 4; pr_type_t *stk = pr->pr_globals + stack; if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 4); @@ -1891,7 +1891,7 @@ pr_stack_push (progs_t *pr) static pr_type_t * pr_stack_pop (progs_t *pr) { - pointer_t stack = *pr->globals.stack; + pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 4); @@ -1904,7 +1904,7 @@ pr_stack_pop (progs_t *pr) static void pr_with (progs_t *pr, const dstatement_t *st) { - pointer_t edict_area = pr->pr_edict_area - pr->pr_globals; + pr_ptr_t edict_area = pr->pr_edict_area - pr->pr_globals; pr_type_t *op_b = pr->pr_globals + PR_BASE (pr, st, B) + st->b; pr_type_t *stk; pr_uint_t *base = &pr->pr_bases[st->c & 3]; @@ -1933,7 +1933,7 @@ pr_with (progs_t *pr, const dstatement_t *st) *base = pr->pr_globals[st->b].pointer_var; return; case 5: - *base = OPB(pointer); + *base = OPB(ptr); return; case 6: // relative to stack (-ve offset) @@ -2755,9 +2755,9 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) } } - pointer_t st_a = st->a + PR_BASE (pr, st, A); - pointer_t st_b = st->b + PR_BASE (pr, st, B); - pointer_t st_c = st->c + PR_BASE (pr, st, C); + pr_ptr_t st_a = st->a + PR_BASE (pr, st, A); + pr_ptr_t st_b = st->b + PR_BASE (pr, st, B); + pr_ptr_t st_c = st->c + PR_BASE (pr, st, C); pr_type_t *op_a = pr->pr_globals + st_a; diff --git a/libs/gamecode/pr_resolve.c b/libs/gamecode/pr_resolve.c index c0c090016..299f8d2ae 100644 --- a/libs/gamecode/pr_resolve.c +++ b/libs/gamecode/pr_resolve.c @@ -44,7 +44,7 @@ static const char param_str[] = ".param_0"; pr_def_t * -PR_SearchDefs (pr_def_t *defs, unsigned num_defs, pointer_t offset) +PR_SearchDefs (pr_def_t *defs, unsigned num_defs, pr_ptr_t offset) { // fuzzy bsearh unsigned left = 0; @@ -69,13 +69,13 @@ PR_SearchDefs (pr_def_t *defs, unsigned num_defs, pointer_t offset) } pr_def_t * -PR_GlobalAtOfs (progs_t * pr, pointer_t ofs) +PR_GlobalAtOfs (progs_t * pr, pr_ptr_t ofs) { return PR_SearchDefs (pr->pr_globaldefs, pr->progs->numglobaldefs, ofs); } VISIBLE pr_def_t * -PR_FieldAtOfs (progs_t * pr, pointer_t ofs) +PR_FieldAtOfs (progs_t * pr, pr_ptr_t ofs) { return PR_SearchDefs (pr->pr_fielddefs, pr->progs->numfielddefs, ofs); } diff --git a/libs/gamecode/pr_strings.c b/libs/gamecode/pr_strings.c index f2e5237a6..3c75984d2 100644 --- a/libs/gamecode/pr_strings.c +++ b/libs/gamecode/pr_strings.c @@ -164,7 +164,7 @@ free_string_ref (prstr_resources_t *res, strref_t *sr) res->free_string_refs = sr; } -static __attribute__((pure)) string_t +static __attribute__((pure)) pr_string_t string_index (prstr_resources_t *res, strref_t *sr) { long o = (long) (sr - res->static_strings); @@ -309,7 +309,7 @@ requeue_strref (prstr_resources_t *res, strref_t *sr) } static inline strref_t * -get_strref (prstr_resources_t *res, string_t num) +get_strref (prstr_resources_t *res, pr_string_t num) { if (num < 0) { strref_t *ref; @@ -328,7 +328,7 @@ get_strref (prstr_resources_t *res, string_t num) } static inline __attribute__((pure)) const char * -get_string (progs_t *pr, string_t num) +get_string (progs_t *pr, pr_string_t num) { __auto_type res = pr->pr_string_resources; if (num < 0) { @@ -356,7 +356,7 @@ get_string (progs_t *pr, string_t num) } VISIBLE qboolean -PR_StringValid (progs_t *pr, string_t num) +PR_StringValid (progs_t *pr, pr_string_t num) { if (num >= 0) { return num < pr->pr_stringsize; @@ -365,7 +365,7 @@ PR_StringValid (progs_t *pr, string_t num) } VISIBLE qboolean -PR_StringMutable (progs_t *pr, string_t num) +PR_StringMutable (progs_t *pr, pr_string_t num) { strref_t *sr; if (num >= 0) { @@ -376,7 +376,7 @@ PR_StringMutable (progs_t *pr, string_t num) } VISIBLE const char * -PR_GetString (progs_t *pr, string_t num) +PR_GetString (progs_t *pr, pr_string_t num) { const char *str; @@ -387,7 +387,7 @@ PR_GetString (progs_t *pr, string_t num) } VISIBLE dstring_t * -PR_GetMutableString (progs_t *pr, string_t num) +PR_GetMutableString (progs_t *pr, pr_string_t num) { strref_t *ref = get_strref (pr->pr_string_resources, num); if (ref) { @@ -424,7 +424,7 @@ pr_strdup (progs_t *pr, const char *s) return new; } -VISIBLE string_t +VISIBLE pr_string_t PR_SetString (progs_t *pr, const char *s) { prstr_resources_t *res = pr->pr_string_resources; @@ -443,7 +443,7 @@ PR_SetString (progs_t *pr, const char *s) return string_index (res, sr); } -VISIBLE string_t +VISIBLE pr_string_t PR_FindString (progs_t *pr, const char *s) { prstr_resources_t *res = pr->pr_string_resources; @@ -459,7 +459,7 @@ PR_FindString (progs_t *pr, const char *s) return 0; } -VISIBLE string_t +VISIBLE pr_string_t PR_SetReturnString (progs_t *pr, const char *s) { prstr_resources_t *res = pr->pr_string_resources; @@ -499,7 +499,7 @@ PR_SetReturnString (progs_t *pr, const char *s) return string_index (res, sr); } -static inline string_t +static inline pr_string_t pr_settempstring (progs_t *pr, prstr_resources_t *res, char *s) { strref_t *sr; @@ -512,7 +512,7 @@ pr_settempstring (progs_t *pr, prstr_resources_t *res, char *s) return string_index (res, sr); } -VISIBLE string_t +VISIBLE pr_string_t PR_CatStrings (progs_t *pr, const char *a, const char *b) { size_t lena; @@ -528,7 +528,7 @@ PR_CatStrings (progs_t *pr, const char *a, const char *b) return pr_settempstring (pr, pr->pr_string_resources, c); } -VISIBLE string_t +VISIBLE pr_string_t PR_SetTempString (progs_t *pr, const char *s) { prstr_resources_t *res = pr->pr_string_resources; @@ -544,7 +544,7 @@ PR_SetTempString (progs_t *pr, const char *s) return pr_settempstring (pr, res, pr_strdup (pr, s)); } -VISIBLE string_t +VISIBLE pr_string_t PR_AllocTempBlock (progs_t *pr, size_t size) { prstr_resources_t *res = pr->pr_string_resources; @@ -552,7 +552,7 @@ PR_AllocTempBlock (progs_t *pr, size_t size) } VISIBLE void -PR_PushTempString (progs_t *pr, string_t num) +PR_PushTempString (progs_t *pr, pr_string_t num) { prstr_resources_t *res = pr->pr_string_resources; strref_t *ref = get_strref (res, num); @@ -572,7 +572,7 @@ PR_PushTempString (progs_t *pr, string_t num) PR_Error (pr, "attempt to push stale temp string"); } -VISIBLE string_t +VISIBLE pr_string_t PR_SetDynamicString (progs_t *pr, const char *s) { prstr_resources_t *res = pr->pr_string_resources; @@ -592,7 +592,7 @@ PR_SetDynamicString (progs_t *pr, const char *s) } VISIBLE void -PR_MakeTempString (progs_t *pr, string_t str) +PR_MakeTempString (progs_t *pr, pr_string_t str) { prstr_resources_t *res = pr->pr_string_resources; strref_t *sr = get_strref (res, str); @@ -613,7 +613,7 @@ PR_MakeTempString (progs_t *pr, string_t str) pr->pr_xtstr = sr; } -VISIBLE string_t +VISIBLE pr_string_t PR_NewMutableString (progs_t *pr) { prstr_resources_t *res = pr->pr_string_resources; @@ -624,7 +624,7 @@ PR_NewMutableString (progs_t *pr) } VISIBLE void -PR_HoldString (progs_t *pr, string_t str) +PR_HoldString (progs_t *pr, pr_string_t str) { prstr_resources_t *res = pr->pr_string_resources; strref_t *sr = get_strref (res, str); @@ -654,7 +654,7 @@ PR_HoldString (progs_t *pr, string_t str) } VISIBLE void -PR_FreeString (progs_t *pr, string_t str) +PR_FreeString (progs_t *pr, pr_string_t str) { prstr_resources_t *res = pr->pr_string_resources; strref_t *sr = get_strref (res, str); diff --git a/libs/gamecode/test/head.c b/libs/gamecode/test/head.c index 07921d847..78410dfe5 100644 --- a/libs/gamecode/test/head.c +++ b/libs/gamecode/test/head.c @@ -29,8 +29,8 @@ static int verbose = 0; typedef struct { const char *desc; - pointer_t edict_area; - pointer_t stack_size; + pr_ptr_t edict_area; + pr_uint_t stack_size; pr_uint_t extra_globals; pr_uint_t num_globals; pr_uint_t num_statements; diff --git a/libs/gamecode/test/main.c b/libs/gamecode/test/main.c index 7a565dece..c9c34be53 100644 --- a/libs/gamecode/test/main.c +++ b/libs/gamecode/test/main.c @@ -109,9 +109,9 @@ setup_test (test_t *test) memset (test_pr.pr_globals + test->num_globals, 0, test->extra_globals * sizeof (pr_type_t)); if (test->stack_size) { - pointer_t stack = num_globals - test->stack_size; + pr_ptr_t stack = num_globals - test->stack_size; test_pr.stack_bottom = stack + 4; - test_pr.globals.stack = (pointer_t *) (test_pr.pr_globals + stack); + test_pr.globals.stack = (pr_ptr_t *) (test_pr.pr_globals + stack); *test_pr.globals.stack = num_globals; } if (test->edict_area) { diff --git a/libs/ruamoko/rua_hash.c b/libs/ruamoko/rua_hash.c index 6448e0b1c..4c8b86049 100644 --- a/libs/ruamoko/rua_hash.c +++ b/libs/ruamoko/rua_hash.c @@ -53,7 +53,7 @@ typedef struct bi_hashtab_s { func_t gh; func_t cmp; func_t f; - pointer_t ud; + pr_ptr_t ud; } bi_hashtab_t; typedef struct { diff --git a/libs/ruamoko/rua_input.c b/libs/ruamoko/rua_input.c index 3cd3156a2..8fefa5fa9 100644 --- a/libs/ruamoko/rua_input.c +++ b/libs/ruamoko/rua_input.c @@ -47,7 +47,7 @@ typedef struct rua_in_cookie_s { size_t users; progs_t *pr; func_t func; - pointer_t data; + pr_ptr_t data; } rua_in_cookie_t; typedef struct input_resources_s { @@ -193,7 +193,7 @@ bi_IN_GetButtonInfo (progs_t *pr) } static rua_in_cookie_t * -make_cookie (progs_t *pr, func_t func, pointer_t data) +make_cookie (progs_t *pr, func_t func, pr_ptr_t data) { input_resources_t *res = PR_Resources_Find (pr, "input"); rua_in_cookie_t search = { @@ -212,7 +212,7 @@ make_cookie (progs_t *pr, func_t func, pointer_t data) } static rua_in_cookie_t * -find_cookie (progs_t *pr, func_t func, pointer_t data) +find_cookie (progs_t *pr, func_t func, pr_ptr_t data) { input_resources_t *res = PR_Resources_Find (pr, "input"); rua_in_cookie_t search = { diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index 22a8b98e7..fafc4fe85 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -76,7 +76,7 @@ typedef struct probj_resources_s { unsigned selector_index; unsigned selector_index_max; obj_list **selector_sels; - string_t *selector_names; + pr_string_t *selector_names; PR_RESMAP (dtable_t) dtables; dtable_t *dtable_list; func_t obj_forward; @@ -423,7 +423,7 @@ object_is_instance (probj_t *probj, pr_id_t *object) return 0; } -static string_t +static pr_string_t object_get_class_name (probj_t *probj, pr_id_t *object) { progs_t *pr = probj->pr; @@ -446,7 +446,7 @@ object_get_class_name (probj_t *probj, pr_id_t *object) //==================================================================== static void -finish_class (probj_t *probj, pr_class_t *class, pointer_t object_ptr) +finish_class (probj_t *probj, pr_class_t *class, pr_ptr_t object_ptr) { progs_t *pr = probj->pr; pr_class_t *meta = &G_STRUCT (pr, pr_class_t, class->class_pointer); @@ -463,7 +463,7 @@ finish_class (probj_t *probj, pr_class_t *class, pointer_t object_ptr) meta->super_class = val->class_pointer; class->super_class = PR_SetPointer (pr, val); } else { - pointer_t *ml = &meta->methods; + pr_ptr_t *ml = &meta->methods; while (*ml) ml = &G_STRUCT (pr, pr_method_list_t, *ml).method_next; *ml = class->methods; @@ -485,7 +485,7 @@ add_sel_name (probj_t *probj, const char *name) probj->selector_sels = realloc (probj->selector_sels, size * sizeof (obj_list *)); probj->selector_names = realloc (probj->selector_names, - size * sizeof (string_t)); + size * sizeof (pr_string_t)); for (i = probj->selector_index_max; i < size; i++) { probj->selector_sels[i] = 0; probj->selector_names[i] = 0; @@ -805,7 +805,7 @@ obj_find_message (probj_t *probj, pr_class_t *class, pr_sel_t *selector) pr_sel_t *sel; int i; int dev = developer->int_val; - string_t *names; + pr_string_t *names; if (dev & SYS_rua_msg) { names = probj->selector_names; @@ -1041,7 +1041,7 @@ obj_verror (probj_t *probj, pr_id_t *object, int code, const char *fmt, int coun } static void -dump_ivars (probj_t *probj, pointer_t _ivars) +dump_ivars (probj_t *probj, pr_ptr_t _ivars) { progs_t *pr = probj->pr; pr_ivar_list_t *ivars; @@ -1063,8 +1063,8 @@ obj_init_statics (probj_t *probj) { progs_t *pr = probj->pr; obj_list **cell = &probj->uninitialized_statics; - pointer_t *ptr; - pointer_t *inst; + pr_ptr_t *ptr; + pr_ptr_t *inst; Sys_MaskPrintf (SYS_rua_obj, "Initializing statics\n"); while (*cell) { @@ -1110,7 +1110,7 @@ rua___obj_exec_class (progs_t *pr) pr_module_t *module = &P_STRUCT (pr, pr_module_t, 0); pr_symtab_t *symtab; pr_sel_t *sel; - pointer_t *ptr; + pr_ptr_t *ptr; int i; obj_list **cell; @@ -1216,7 +1216,7 @@ rua___obj_exec_class (progs_t *pr) if (*ptr) { Sys_MaskPrintf (SYS_rua_obj, "Static instances lists: %x\n", *ptr); probj->uninitialized_statics - = list_cons (&G_STRUCT (pr, pointer_t, *ptr), + = list_cons (&G_STRUCT (pr, pr_ptr_t, *ptr), probj->uninitialized_statics); } if (probj->uninitialized_statics) { @@ -1275,7 +1275,7 @@ rua___obj_forward (progs_t *pr) //FIXME oh for a stack size_t parm_size = pr->pr_param_size * sizeof(pr_type_t); size_t size = pr->pr_argc * parm_size; - string_t args_block = PR_AllocTempBlock (pr, size); + pr_string_t args_block = PR_AllocTempBlock (pr, size); int argc = pr->pr_argc; __auto_type argv = (pr_type_t *) PR_GetString (pr, args_block); @@ -1402,9 +1402,9 @@ static void rua_obj_msg_sendv (progs_t *pr) { probj_t *probj = pr->pr_objective_resources; - pointer_t obj = P_POINTER (pr, 0); + pr_ptr_t obj = P_POINTER (pr, 0); pr_id_t *receiver = &P_STRUCT (pr, pr_id_t, 0); - pointer_t sel = P_POINTER (pr, 1); + pr_ptr_t sel = P_POINTER (pr, 1); pr_sel_t *op = &P_STRUCT (pr, pr_sel_t, 1); func_t imp = obj_msg_lookup (probj, receiver, op); @@ -1679,12 +1679,12 @@ rua_class_pose_as (progs_t *pr) { pr_class_t *impostor = &P_STRUCT (pr, pr_class_t, 0); pr_class_t *superclass = &P_STRUCT (pr, pr_class_t, 1); - pointer_t *subclass; + pr_ptr_t *subclass; subclass = &superclass->subclass_list; while (*subclass) { pr_class_t *sub = &P_STRUCT (pr, pr_class_t, *subclass); - pointer_t nextSub = sub->sibling_class; + pr_ptr_t nextSub = sub->sibling_class; if (sub != impostor) { sub->sibling_class = impostor->subclass_list; sub->super_class = P_POINTER (pr, 0); // impostor @@ -2157,7 +2157,7 @@ rua_init_finish (progs_t *pr) class_list = (pr_class_t **) Hash_GetList (probj->classes); if (*class_list) { pr_class_t *object_class; - pointer_t object_ptr; + pr_ptr_t object_ptr; object_class = Hash_Find (probj->classes, "Object"); if (object_class && !object_class->super_class) @@ -2249,7 +2249,7 @@ RUA_Obj_Init (progs_t *pr, int secure) } func_t -RUA_Obj_msg_lookup (progs_t *pr, pointer_t _self, pointer_t __cmd) +RUA_Obj_msg_lookup (progs_t *pr, pr_ptr_t _self, pr_ptr_t __cmd) { probj_t *probj = pr->pr_objective_resources; pr_id_t *self = &G_STRUCT (pr, pr_id_t, _self); diff --git a/libs/ruamoko/rua_qfile.c b/libs/ruamoko/rua_qfile.c index 8c6c45ef1..55e36acd1 100644 --- a/libs/ruamoko/rua_qfile.c +++ b/libs/ruamoko/rua_qfile.c @@ -213,7 +213,7 @@ bi_Qreadstring (progs_t *pr) int handle = P_INT (pr, 0); int len = P_INT (pr, 1); qfile_t *h = get_handle (pr, __FUNCTION__, handle); - string_t str = PR_NewMutableString (pr); + pr_string_t str = PR_NewMutableString (pr); dstring_t *dstr = PR_GetMutableString (pr, str); dstr->size = len + 1; diff --git a/libs/ruamoko/rua_qfs.c b/libs/ruamoko/rua_qfs.c index 4a3eebb59..c29dc3ec8 100644 --- a/libs/ruamoko/rua_qfs.c +++ b/libs/ruamoko/rua_qfs.c @@ -45,7 +45,7 @@ typedef struct { int count; - pointer_t list; + pr_ptr_t list; } qfslist_t; static void @@ -155,7 +155,7 @@ bi_QFS_Filelist (progs_t *pr) { filelist_t *filelist = QFS_FilelistNew (); qfslist_t *list; - string_t *strings; + pr_string_t *strings; int i; QFS_FilelistFill (filelist, P_GSTRING (pr, 0), P_GSTRING (pr, 1), @@ -163,7 +163,7 @@ bi_QFS_Filelist (progs_t *pr) list = PR_Zone_Malloc (pr, sizeof (list) + filelist->count * 4); list->count = filelist->count; - strings = (string_t *) (list + 1); + strings = (pr_string_t *) (list + 1); list->list = PR_SetPointer (pr, strings); for (i = 0; i < filelist->count; i++) strings[i] = PR_SetDynamicString (pr, filelist->list[i]); @@ -174,7 +174,7 @@ static void bi_QFS_FilelistFree (progs_t *pr) { qfslist_t *list = &P_STRUCT (pr, qfslist_t, 0); - string_t *strings = &G_STRUCT (pr, string_t, list->list); + pr_string_t *strings = &G_STRUCT (pr, pr_string_t, list->list); int i; for (i = 0; i < list->count; i++) diff --git a/libs/ruamoko/rua_runtime.c b/libs/ruamoko/rua_runtime.c index 24a8a894d..3fe21db51 100644 --- a/libs/ruamoko/rua_runtime.c +++ b/libs/ruamoko/rua_runtime.c @@ -56,7 +56,7 @@ bi_va_copy (progs_t *pr) __auto_type src_list = &G_STRUCT (pr, pr_type_t, src_args->list); size_t parm_size = pr->pr_param_size * sizeof(pr_type_t); size_t size = src_args->count * parm_size; - string_t dst_list_block = 0; + pr_string_t dst_list_block = 0; pr_type_t *dst_list = 0; if (size) { diff --git a/libs/ruamoko/rua_script.c b/libs/ruamoko/rua_script.c index 4723bfcbe..cfb9a7e9a 100644 --- a/libs/ruamoko/rua_script.c +++ b/libs/ruamoko/rua_script.c @@ -46,7 +46,7 @@ typedef struct { script_t script; - string_t dstr; + pr_string_t dstr; progs_t *pr; } rua_script_t; diff --git a/libs/ruamoko/rua_set.c b/libs/ruamoko/rua_set.c index cc7ce9735..632a6a10a 100644 --- a/libs/ruamoko/rua_set.c +++ b/libs/ruamoko/rua_set.c @@ -432,8 +432,8 @@ bi_i_SetIterator__element (progs_t *pr) static void bi_i_Set__add_ (progs_t *pr) { - pointer_t set_ptr = P_POINTER (pr, 0); - pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); + pr_ptr_t set_ptr = P_POINTER (pr, 0); + pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); PR_RESET_PARAMS (pr); P_INT (pr, 0) = set_obj->set; @@ -445,8 +445,8 @@ bi_i_Set__add_ (progs_t *pr) static void bi_i_Set__remove_ (progs_t *pr) { - pointer_t set_ptr = P_POINTER (pr, 0); - pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); + pr_ptr_t set_ptr = P_POINTER (pr, 0); + pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); PR_RESET_PARAMS (pr); P_INT (pr, 0) = set_obj->set; @@ -458,8 +458,8 @@ bi_i_Set__remove_ (progs_t *pr) static void bi_i_Set__invert (progs_t *pr) { - pointer_t set_ptr = P_POINTER (pr, 0); - pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); + pr_ptr_t set_ptr = P_POINTER (pr, 0); + pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); PR_RESET_PARAMS (pr); P_INT (pr, 0) = set_obj->set; @@ -470,8 +470,8 @@ bi_i_Set__invert (progs_t *pr) static void bi_i_Set__union_ (progs_t *pr) { - pointer_t dst_ptr = P_POINTER (pr, 0); - pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); + pr_ptr_t dst_ptr = P_POINTER (pr, 0); + pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); PR_RESET_PARAMS (pr); @@ -484,9 +484,9 @@ bi_i_Set__union_ (progs_t *pr) static void bi_i_Set__intersection_ (progs_t *pr) { - pointer_t dst_ptr = P_POINTER (pr, 0); - pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); - pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); + pr_ptr_t dst_ptr = P_POINTER (pr, 0); + pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); + pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); PR_RESET_PARAMS (pr); P_INT (pr, 0) = dst_obj->set; @@ -498,9 +498,9 @@ bi_i_Set__intersection_ (progs_t *pr) static void bi_i_Set__difference_ (progs_t *pr) { - pointer_t dst_ptr = P_POINTER (pr, 0); - pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); - pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); + pr_ptr_t dst_ptr = P_POINTER (pr, 0); + pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); + pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); PR_RESET_PARAMS (pr); P_INT (pr, 0) = dst_obj->set; @@ -512,9 +512,9 @@ bi_i_Set__difference_ (progs_t *pr) static void bi_i_Set__reverse_difference_ (progs_t *pr) { - pointer_t dst_ptr = P_POINTER (pr, 0); - pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); - pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); + pr_ptr_t dst_ptr = P_POINTER (pr, 0); + pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); + pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); PR_RESET_PARAMS (pr); P_INT (pr, 0) = dst_obj->set; @@ -526,9 +526,9 @@ bi_i_Set__reverse_difference_ (progs_t *pr) static void bi_i_Set__assign_ (progs_t *pr) { - pointer_t dst_ptr = P_POINTER (pr, 0); - pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); - pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); + pr_ptr_t dst_ptr = P_POINTER (pr, 0); + pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); + pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); PR_RESET_PARAMS (pr); P_INT (pr, 0) = dst_obj->set; @@ -540,8 +540,8 @@ bi_i_Set__assign_ (progs_t *pr) static void bi_i_Set__empty (progs_t *pr) { - pointer_t set_ptr = P_POINTER (pr, 0); - pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); + pr_ptr_t set_ptr = P_POINTER (pr, 0); + pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); PR_RESET_PARAMS (pr); P_INT (pr, 0) = set_obj->set; @@ -552,8 +552,8 @@ bi_i_Set__empty (progs_t *pr) static void bi_i_Set__everything (progs_t *pr) { - pointer_t set_ptr = P_POINTER (pr, 0); - pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); + pr_ptr_t set_ptr = P_POINTER (pr, 0); + pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); PR_RESET_PARAMS (pr); P_INT (pr, 0) = set_obj->set; diff --git a/libs/ruamoko/rua_string.c b/libs/ruamoko/rua_string.c index 754d1627e..c808ae963 100644 --- a/libs/ruamoko/rua_string.c +++ b/libs/ruamoko/rua_string.c @@ -108,7 +108,7 @@ bi_str_free (progs_t *pr) static void bi_str_hold (progs_t *pr) { - string_t str = P_STRING (pr, 0); + pr_string_t str = P_STRING (pr, 0); PR_HoldString (pr, str); R_STRING (pr) = str; } diff --git a/nq/include/sv_progs.h b/nq/include/sv_progs.h index 0d0ea9635..975515eb0 100644 --- a/nq/include/sv_progs.h +++ b/nq/include/sv_progs.h @@ -44,8 +44,8 @@ typedef struct { float *time; float *frametime; float *force_retouch; - string_t *mapname; - string_t *startspot; + pr_string_t *mapname; + pr_string_t *startspot; float *deathmatch; float *coop; float *teamplay; @@ -68,7 +68,7 @@ typedef struct { float *trace_inopen; float *trace_inwater; pr_uint_t *msg_entity; - string_t *null; + pr_string_t *null; pr_uint_t *newmis; } sv_globals_t; @@ -106,8 +106,8 @@ typedef struct pr_int_t angles; //vec3_t pr_int_t avelocity; //vec3_t pr_int_t punchangle; //vec3_t - pr_int_t classname; //string_t - pr_int_t model; //string_t + pr_int_t classname; //pr_string_t + pr_int_t model; //pr_string_t pr_int_t frame; //float pr_int_t skin; //float pr_int_t effects; //float @@ -123,7 +123,7 @@ typedef struct pr_int_t health; //float pr_int_t frags; //float pr_int_t weapon; //float - pr_int_t weaponmodel; //string_t + pr_int_t weaponmodel; //pr_string_t pr_int_t weaponframe; //float pr_int_t currentammo; //float pr_int_t ammo_shells; //float @@ -142,7 +142,7 @@ typedef struct pr_int_t fixangle; //float pr_int_t v_angle; //vec3_t pr_int_t idealpitch; //float - pr_int_t netname; //string_t + pr_int_t netname; //pr_string_t pr_int_t enemy; //int pr_int_t flags; //float pr_int_t colormap; //float @@ -160,7 +160,7 @@ typedef struct pr_int_t dmg_inflictor; //int pr_int_t owner; //int pr_int_t movedir; //vec3_t - pr_int_t message; //string_t + pr_int_t message; //pr_string_t pr_int_t sounds; //float pr_int_t rotated_bbox; //int diff --git a/qw/include/sv_progs.h b/qw/include/sv_progs.h index d0c04e2e0..c3391e2fb 100644 --- a/qw/include/sv_progs.h +++ b/qw/include/sv_progs.h @@ -45,7 +45,7 @@ typedef struct { float *frametime; pr_uint_t *newmis; float *force_retouch; - string_t *mapname; + pr_string_t *mapname; float *serverflags; float *total_secrets; float *total_monsters; @@ -108,8 +108,8 @@ typedef struct pr_int_t velocity; //vec3_t pr_int_t angles; //vec3_t pr_int_t avelocity; //vec3_t - pr_int_t classname; //string_t - pr_int_t model; //string_t + pr_int_t classname; //pr_string_t + pr_int_t model; //pr_string_t pr_int_t frame; //float pr_int_t skin; //float pr_int_t effects; //float @@ -124,7 +124,7 @@ typedef struct pr_int_t health; //float pr_int_t frags; //float pr_int_t weapon; //float - pr_int_t weaponmodel; //string_t + pr_int_t weaponmodel; //pr_string_t pr_int_t weaponframe; //float pr_int_t currentammo; //float pr_int_t ammo_shells; //float @@ -141,7 +141,7 @@ typedef struct pr_int_t impulse; //float pr_int_t fixangle; //float pr_int_t v_angle; //vec3_t - pr_int_t netname; //string_t + pr_int_t netname; //pr_string_t pr_int_t enemy; //int pr_int_t flags; //float pr_int_t colormap; //float @@ -158,7 +158,7 @@ typedef struct pr_int_t dmg_save; //float pr_int_t dmg_inflictor; //int pr_int_t owner; //int - pr_int_t message; //string_t + pr_int_t message; //pr_string_t pr_int_t sounds; //float pr_int_t rotated_bbox; //int diff --git a/qw/source/sv_pr_cpqw.c b/qw/source/sv_pr_cpqw.c index e2ac3ffd2..19be9ac13 100644 --- a/qw/source/sv_pr_cpqw.c +++ b/qw/source/sv_pr_cpqw.c @@ -446,7 +446,7 @@ PF_putsaytime (progs_t *pr) static void PF_makestr (progs_t *pr) { - string_t res = PR_NewMutableString (pr); + pr_string_t res = PR_NewMutableString (pr); dstring_t *dst = PR_GetMutableString (pr, res); const char *src = P_GSTRING (pr, 0); diff --git a/ruamoko/qwaq/builtins/debug.c b/ruamoko/qwaq/builtins/debug.c index 56aaa818c..4fa0b0c98 100644 --- a/ruamoko/qwaq/builtins/debug.c +++ b/ruamoko/qwaq/builtins/debug.c @@ -204,7 +204,7 @@ static void qdb_set_trace (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); int state = P_INT (pr, 1); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; @@ -216,7 +216,7 @@ static void qdb_set_breakpoint (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); unsigned staddr = P_INT (pr, 1); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; @@ -234,7 +234,7 @@ static void qdb_clear_breakpoint (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); unsigned staddr = P_UINT (pr, 1); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; @@ -251,8 +251,8 @@ static void qdb_set_watchpoint (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); - pointer_t offset = P_UINT (pr, 1); + pr_ptr_t handle = P_INT (pr, 0); + pr_ptr_t offset = P_UINT (pr, 1); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; @@ -268,7 +268,7 @@ static void qdb_clear_watchpoint (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; @@ -280,7 +280,7 @@ static void qdb_continue (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); pthread_mutex_lock (&target->run_cond.mut); @@ -293,12 +293,12 @@ static void qdb_get_state (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; pr_lineno_t *lineno; pr_auxfunction_t *f; - string_t file = 0; + pr_string_t file = 0; unsigned line = 0; unsigned staddr = tpr->pr_xstatement; func_t func = 0; @@ -331,7 +331,7 @@ static void qdb_get_stack_depth (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; @@ -342,7 +342,7 @@ static void qdb_get_stack (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; int count = tpr->pr_depth; @@ -350,7 +350,7 @@ qdb_get_stack (progs_t *pr) R_POINTER (pr) = 0; if (count > 0) { size_t size = count * sizeof (qdb_stack_t); - string_t stack_block = PR_AllocTempBlock (pr, size); + pr_string_t stack_block = PR_AllocTempBlock (pr, size); __auto_type stack = (qdb_stack_t *) PR_GetString (pr, stack_block); for (int i = 0; i < count; i++) { @@ -366,7 +366,7 @@ static void qdb_get_event (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); __auto_type event = &P_STRUCT (pr, qdb_event_t, 1); @@ -400,12 +400,12 @@ static void qdb_get_data (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; - pointer_t srcoff = P_POINTER (pr, 1); + pr_ptr_t srcoff = P_POINTER (pr, 1); unsigned length = P_UINT (pr, 2); - pointer_t dstoff = P_POINTER(pr, 3); + pr_ptr_t dstoff = P_POINTER(pr, 3); pr_type_t *src = PR_GetPointer(tpr, srcoff); pr_type_t *dst = PR_GetPointer(pr, dstoff); @@ -426,10 +426,10 @@ static void qdb_get_string (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; - string_t string = P_STRING (pr, 1); + pr_string_t string = P_STRING (pr, 1); R_STRING (pr) = 0; if (PR_StringValid (tpr, string)) { @@ -441,7 +441,7 @@ static void qdb_get_file_path (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; const char *file = P_GSTRING (pr, 1); @@ -466,7 +466,7 @@ static void qdb_find_string (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; const char *str = P_GSTRING (pr, 1); @@ -478,7 +478,7 @@ static void qdb_find_global (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; const char *name = P_GSTRING (pr, 1); @@ -498,7 +498,7 @@ static void qdb_find_field (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; const char *name = P_GSTRING (pr, 1); @@ -536,7 +536,7 @@ static void qdb_find_function (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; const char *name = P_GSTRING (pr, 1); @@ -549,7 +549,7 @@ static void qdb_get_function (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; pr_uint_t fnum = P_INT (pr, 1); @@ -583,7 +583,7 @@ static void qdb_find_auxfunction (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; const char *name = P_GSTRING (pr, 1); @@ -601,7 +601,7 @@ static void qdb_get_auxfunction (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; pr_uint_t fnum = P_UINT (pr, 1); @@ -614,7 +614,7 @@ static void qdb_get_local_defs (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; pr_uint_t fnum = P_UINT (pr, 1); @@ -640,7 +640,7 @@ static void qdb_get_source_line_addr (progs_t *pr) { __auto_type debug = PR_Resources_Find (pr, "qwaq-debug"); - pointer_t handle = P_INT (pr, 0); + pr_ptr_t handle = P_INT (pr, 0); qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; const char *file = P_GSTRING (pr, 1); diff --git a/ruamoko/qwaq/builtins/main.c b/ruamoko/qwaq/builtins/main.c index f8d4c3a62..185998fde 100644 --- a/ruamoko/qwaq/builtins/main.c +++ b/ruamoko/qwaq/builtins/main.c @@ -239,7 +239,7 @@ spawn_progs (qwaq_thread_t *thread) { dfunction_t *dfunc; const char *name = 0; - string_t *pr_argv; + pr_string_t *pr_argv; int pr_argc = 1, i; progs_t *pr; diff --git a/ruamoko/qwaq/debugger/debug.h b/ruamoko/qwaq/debugger/debug.h index e9c1cedcf..bfc0d4f88 100644 --- a/ruamoko/qwaq/debugger/debug.h +++ b/ruamoko/qwaq/debugger/debug.h @@ -16,14 +16,14 @@ typedef enum { #define umax 0x7fffffff #endif -typedef string string_t; +typedef string pr_string_t; #endif typedef struct qdb_event_s { prdebug_t what; union { - string_t message; + pr_string_t message; unsigned function; int exit_code; }; @@ -32,7 +32,7 @@ typedef struct qdb_event_s { typedef struct qdb_state_s { unsigned staddr; unsigned func; - string_t file; + pr_string_t file; unsigned line; } qdb_state_t; diff --git a/ruamoko/qwaq/editor/editbuffer.h b/ruamoko/qwaq/editor/editbuffer.h index 8d42c6038..08a13d213 100644 --- a/ruamoko/qwaq/editor/editbuffer.h +++ b/ruamoko/qwaq/editor/editbuffer.h @@ -81,7 +81,7 @@ typedef struct eb_color_s { typedef struct qwaq_editbuffer_s { pr_id_t isa; - pointer_t buffer; + pr_ptr_t buffer; } qwaq_editbuffer_t; #endif//!__QFCC__ diff --git a/ruamoko/qwaq/qwaq-input.h b/ruamoko/qwaq/qwaq-input.h index f385917e5..959015a33 100644 --- a/ruamoko/qwaq/qwaq-input.h +++ b/ruamoko/qwaq/qwaq-input.h @@ -9,20 +9,20 @@ typedef struct qwaq_devinfo_s { string name; string id; #else - string_t name; - string_t id; + pr_string_t name; + pr_string_t id; #endif int numaxes; #ifdef __QFCC__ in_axisinfo_t *axes; #else - pointer_t axes; + pr_ptr_t axes; #endif int numbuttons; #ifdef __QFCC__ in_axisinfo_t *buttons; #else - pointer_t buttons; + pr_ptr_t buttons; #endif } qwaq_devinfo_t; diff --git a/ruamoko/qwaq/ui/event.h b/ruamoko/qwaq/ui/event.h index 8a9f3c608..571e256f6 100644 --- a/ruamoko/qwaq/ui/event.h +++ b/ruamoko/qwaq/ui/event.h @@ -74,8 +74,8 @@ typedef union qwaq_message_s { void *pointer_val; string string_val; #else - pointer_t pointer_val; - string_t string_val; + pr_ptr_t pointer_val; + pr_string_t string_val; #endif } qwaq_message_t; diff --git a/ruamoko/qwaq/ui/textcontext.h b/ruamoko/qwaq/ui/textcontext.h index d73a9895c..168a7b9c0 100644 --- a/ruamoko/qwaq/ui/textcontext.h +++ b/ruamoko/qwaq/ui/textcontext.h @@ -65,7 +65,7 @@ typedef struct qwaq_textcontext_s { pr_id_t isa; - pointer_t window; + pr_ptr_t window; union { Rect rect; struct { diff --git a/tools/qfcc/include/def.h b/tools/qfcc/include/def.h index c03b221ef..f49dd2f8e 100644 --- a/tools/qfcc/include/def.h +++ b/tools/qfcc/include/def.h @@ -98,7 +98,7 @@ typedef struct def_s { unsigned system:1; ///< system def unsigned nosave:1; ///< don't set DEF_SAVEGLOBAL - string_t file; ///< declaring/defining source file + pr_string_t file; ///< declaring/defining source file int line; ///< declaring/defining source line int qfo_def; ///< index to def in qfo defs diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 59ac358e4..61ff0b7ca 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -243,7 +243,7 @@ typedef struct expr_s { struct expr_s *next; ///< the next expression in a block expression expr_type type; ///< the type of the result of this expression int line; ///< source line that generated this expression - string_t file; ///< source file that generated this expression + pr_string_t file; ///< source file that generated this expression int printid; ///< avoid duplicate output when printing unsigned paren:1; ///< the expression is enclosed in () unsigned rvalue:1; ///< the expression is on the right side of = diff --git a/tools/qfcc/include/function.h b/tools/qfcc/include/function.h index 986f513eb..4f8fa83e7 100644 --- a/tools/qfcc/include/function.h +++ b/tools/qfcc/include/function.h @@ -53,7 +53,7 @@ typedef struct overloaded_function_s { ///< encoding const struct type_s *type; ///< type of this function int overloaded; ///< is this function overloaded - string_t file; ///< source file of the function + pr_string_t file; ///< source file of the function int line; ///< source line of this function } overloaded_function_t; @@ -66,8 +66,8 @@ typedef struct function_s { int function_num; int line_info; int local_defs; - string_t s_file; ///< source file with definition - string_t s_name; ///< name of function in output + pr_string_t s_file; ///< source file with definition + pr_string_t s_name; ///< name of function in output const struct type_s *type; ///< function's type without aliases int temp_num; ///< number for next temp var struct def_s *temp_defs[4]; ///< freed temp vars (by size) diff --git a/tools/qfcc/include/obj_file.h b/tools/qfcc/include/obj_file.h index 8d6c40a22..2aec16095 100644 --- a/tools/qfcc/include/obj_file.h +++ b/tools/qfcc/include/obj_file.h @@ -97,16 +97,16 @@ typedef struct qfo_space_s { /** Representation of a def in the object file. */ typedef struct qfo_def_s { - pointer_t type; ///< offset in type space - string_t name; ///< def name - pointer_t offset; ///< def offset (address) + pr_ptr_t type; ///< offset in type space + pr_string_t name; ///< def name + pr_ptr_t offset; ///< def offset (address) pr_uint_t relocs; ///< index of first reloc record pr_uint_t num_relocs; ///< number of reloc records pr_uint_t flags; ///< \ref qfcc_qfo_QFOD "QFOD flags" - string_t file; ///< source file name + pr_string_t file; ///< source file name pr_uint_t line; ///< source line number } qfo_def_t; ///@} @@ -180,9 +180,9 @@ typedef struct qfo_def_s { /** Representation of a function in the object file. */ typedef struct qfo_func_s { - string_t name; ///< function name - pointer_t type; ///< function type (in type data space) - string_t file; ///< source file name + pr_string_t name; ///< function name + pr_ptr_t type; ///< function type (in type data space) + pr_string_t file; ///< source file name pr_uint_t line; ///< source line number /** \name Function code location. @@ -367,7 +367,7 @@ enum { \param q pointer to ::qfo_t struct \param s space index \param o offset into object file data space - \return string_t lvalue + \return pr_string_t lvalue \hideinitializer */ diff --git a/tools/qfcc/include/qfcc.h b/tools/qfcc/include/qfcc.h index 4ac5e0ddb..c129e8271 100644 --- a/tools/qfcc/include/qfcc.h +++ b/tools/qfcc/include/qfcc.h @@ -45,7 +45,7 @@ typedef struct srcline_s srcline_t; struct srcline_s { srcline_t *next; - string_t source_file; + pr_string_t source_file; int source_line; }; @@ -79,7 +79,7 @@ typedef struct pr_info_s { struct symtab_s *entity_fields; srcline_t *srcline_stack; - string_t source_file; + pr_string_t source_file; int source_line; int error_count; diff --git a/tools/qfcc/include/reloc.h b/tools/qfcc/include/reloc.h index dc6e802c8..98c828e60 100644 --- a/tools/qfcc/include/reloc.h +++ b/tools/qfcc/include/reloc.h @@ -77,7 +77,7 @@ typedef struct reloc_s { ///< adjustment reloc_type type; ///< type type of relocation to perform int line; ///< current source line when creating reloc - string_t file; ///< current source file when creating reloc + pr_string_t file; ///< current source file when creating reloc const void *return_address; ///< for debugging } reloc_t; diff --git a/tools/qfcc/source/class.c b/tools/qfcc/source/class.c index 7858f82fa..99d6fbcb2 100644 --- a/tools/qfcc/source/class.c +++ b/tools/qfcc/source/class.c @@ -276,7 +276,7 @@ emit_static_instances_list (void) type_t *instance_lists_type; symbol_t *instance_lists_sym; def_t *instance_lists_def; - pointer_t *list; + pr_ptr_t *list; defspace_t *space; if (!static_instance_classes || !static_instances) { @@ -309,7 +309,7 @@ emit_static_instances_list (void) instance_lists_def->initialized = instance_lists_def->constant = 1; instance_lists_def->nosave = 1; - list = D_POINTER (pointer_t, instance_lists_def); + list = D_POINTER (pr_ptr_t, instance_lists_def); space = instance_lists_def->space; for (int i = 0; i < num_classes; i++, list++) { EMIT_DEF (space, *list, instance_lists[i]); diff --git a/tools/qfcc/source/diagnostic.c b/tools/qfcc/source/diagnostic.c index 9169b42f9..6410fae1e 100644 --- a/tools/qfcc/source/diagnostic.c +++ b/tools/qfcc/source/diagnostic.c @@ -50,8 +50,8 @@ static void report_function (const expr_t *e) { static function_t *last_func = (function_t *)-1L; - static string_t last_file; - string_t file = pr.source_file; + static pr_string_t last_file; + pr_string_t file = pr.source_file; srcline_t *srcline; if (e) @@ -81,7 +81,7 @@ static __attribute__((format(PRINTF, 4, 0))) void format_message (dstring_t *message, const char *msg_type, const expr_t *e, const char *fmt, va_list args) { - string_t file = pr.source_file; + pr_string_t file = pr.source_file; int line = pr.source_line; const char *colon = fmt ? ": " : ""; diff --git a/tools/qfcc/source/dump_globals.c b/tools/qfcc/source/dump_globals.c index ff8f6d32f..f27f33d4b 100644 --- a/tools/qfcc/source/dump_globals.c +++ b/tools/qfcc/source/dump_globals.c @@ -65,7 +65,7 @@ dump_def (progs_t *pr, pr_def_t *def, int indent) const char *type; pr_uint_t offset; const char *comment; - string_t string; + pr_string_t string; const char *str; int saveglobal; @@ -86,7 +86,7 @@ dump_def (progs_t *pr, pr_def_t *def, int indent) break; case ev_string: string = G_INT (pr, offset); - // at runtime, strings can be negative (thus string_t is + // at runtime, strings can be negative (thus pr_string_t is // signed), but negative strings means they have been // dynamically allocated, thus a negative string index should // never appear in compiled code @@ -241,7 +241,7 @@ dump_functions (progs_t *pr) int start; const char *comment; pr_def_t *encodings_def; - pointer_t type_encodings = 0; + pr_ptr_t type_encodings = 0; encodings_def = PR_FindGlobal (pr, ".type_encodings"); if (encodings_def) { @@ -516,7 +516,7 @@ static const char *ty_meta_names[] = { static void dump_qfo_types (qfo_t *qfo, int base_address) { - pointer_t type_ptr; + pr_ptr_t type_ptr; qfot_type_t *type; const char *meta; int i, count; diff --git a/tools/qfcc/source/dump_lines.c b/tools/qfcc/source/dump_lines.c index 7ff66fabb..f021e48a3 100644 --- a/tools/qfcc/source/dump_lines.c +++ b/tools/qfcc/source/dump_lines.c @@ -52,7 +52,7 @@ typedef struct { const char *source_file; pr_uint_t source_line; pr_int_t first_statement; - pointer_t return_type; + pr_ptr_t return_type; pr_uint_t local_defs; pr_uint_t num_locals; pr_uint_t line_info; diff --git a/tools/qfcc/source/dump_modules.c b/tools/qfcc/source/dump_modules.c index 3897610b7..5f0f590f2 100644 --- a/tools/qfcc/source/dump_modules.c +++ b/tools/qfcc/source/dump_modules.c @@ -130,7 +130,7 @@ dump_protocol (progs_t *pr, pr_protocol_t *proto) { const char *protocol_name = ""; printf (" %x %x ", - (pointer_t) ((pr_int_t *) proto - (pr_int_t *) pr->pr_globals), + (pr_ptr_t) ((pr_int_t *) proto - (pr_int_t *) pr->pr_globals), proto->class_pointer); if (PR_StringValid (pr, proto->protocol_name)) protocol_name = PR_GetString (pr, proto->protocol_name); @@ -216,9 +216,9 @@ dump_category (progs_t *pr, pr_category_t *category) } static void -dump_static_instance_lists (progs_t *pr, pointer_t instance_lists) +dump_static_instance_lists (progs_t *pr, pr_ptr_t instance_lists) { - pointer_t *ptr = &G_STRUCT (pr, pointer_t, instance_lists); + pr_ptr_t *ptr = &G_STRUCT (pr, pr_ptr_t, instance_lists); printf (" static instance lists @ %x\n", instance_lists); while (*ptr) { @@ -245,7 +245,7 @@ static void dump_module (progs_t *pr, pr_module_t *module) { pr_symtab_t *symtab = &G_STRUCT (pr, pr_symtab_t, module->symtab); - pointer_t *ptr = symtab->defs; + pr_ptr_t *ptr = symtab->defs; pr_sel_t *sel = &G_STRUCT (pr, pr_sel_t, symtab->refs); int i; const char *module_name = ""; diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index ae3f919dc..0b70c6ae4 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -2551,7 +2551,7 @@ expr_t * build_if_statement (int not, expr_t *test, expr_t *s1, expr_t *els, expr_t *s2) { int line = pr.source_line; - string_t file = pr.source_file; + pr_string_t file = pr.source_file; expr_t *if_expr; expr_t *tl = new_label_expr (); expr_t *fl = new_label_expr (); @@ -2610,7 +2610,7 @@ build_while_statement (int not, expr_t *test, expr_t *statement, expr_t *break_label, expr_t *continue_label) { int line = pr.source_line; - string_t file = pr.source_file; + pr_string_t file = pr.source_file; expr_t *l1 = new_label_expr (); expr_t *l2 = break_label; expr_t *while_expr; @@ -2650,7 +2650,7 @@ build_do_while_statement (expr_t *statement, int not, expr_t *test, { expr_t *l1 = new_label_expr (); int line = pr.source_line; - string_t file = pr.source_file; + pr_string_t file = pr.source_file; expr_t *do_while_expr; if (!statement) { @@ -2696,7 +2696,7 @@ build_for_statement (expr_t *init, expr_t *test, expr_t *next, expr_t *l1 = 0; expr_t *t; int line = pr.source_line; - string_t file = pr.source_file; + pr_string_t file = pr.source_file; expr_t *for_expr; if (next) diff --git a/tools/qfcc/source/linker.c b/tools/qfcc/source/linker.c index 948ac084f..cc34e79b6 100644 --- a/tools/qfcc/source/linker.c +++ b/tools/qfcc/source/linker.c @@ -245,7 +245,7 @@ defs_get_key (const void *_r, void *unused) int linker_add_string (const char *str) { - string_t new; + pr_string_t new; new = strpool_addstr (work_strings, str); work->spaces[qfo_strings_space].strings = work_strings->strings; work->spaces[qfo_strings_space].data_size = work_strings->size; @@ -875,7 +875,7 @@ process_type_space (qfo_t *qfo, qfo_mspace_t *space, int pass) // while we're at it, relocate all references in the type encoding // space so the type encodings are always correct. if (reloc->type == rel_def_string) { - string_t str; + pr_string_t str; str = linker_add_string (QFOSTR (qfo, reloc->target)); QFO_STRING (work, reloc->space, reloc->offset) = str; } else if (reloc->type == rel_def_def || reloc->type == -1) { diff --git a/tools/qfcc/source/obj_file.c b/tools/qfcc/source/obj_file.c index 2082fe8ca..eed5de4ce 100644 --- a/tools/qfcc/source/obj_file.c +++ b/tools/qfcc/source/obj_file.c @@ -678,7 +678,7 @@ qfo_delete (qfo_t *qfo) } static etype_t -get_def_type (qfo_t *qfo, pointer_t type) +get_def_type (qfo_t *qfo, pr_ptr_t type) { qfot_type_t *type_def; if (type >= qfo->spaces[qfo_type_space].data_size) @@ -705,7 +705,7 @@ get_def_type (qfo_t *qfo, pointer_t type) } static __attribute__((pure)) int -get_type_size (qfo_t *qfo, pointer_t type) +get_type_size (qfo_t *qfo, pr_ptr_t type) { qfot_type_t *type_def; int i, size; @@ -755,7 +755,7 @@ qfo_log2 (unsigned x) } static __attribute__((pure)) int -get_type_alignment_log (qfo_t *qfo, pointer_t type) +get_type_alignment_log (qfo_t *qfo, pr_ptr_t type) { qfot_type_t *type_def; int i, alignment; @@ -791,7 +791,7 @@ get_type_alignment_log (qfo_t *qfo, pointer_t type) } static __attribute__((pure)) dparmsize_t -get_parmsize (qfo_t *qfo, pointer_t type) +get_parmsize (qfo_t *qfo, pr_ptr_t type) { dparmsize_t parmsize = { get_type_size (qfo, type), diff --git a/tools/qfcc/source/obj_type.c b/tools/qfcc/source/obj_type.c index 7f87e43df..09927ecd3 100644 --- a/tools/qfcc/source/obj_type.c +++ b/tools/qfcc/source/obj_type.c @@ -65,7 +65,7 @@ typedef def_t *(*encode_f) (type_t *type, defspace_t *space); -static string_t +static pr_string_t encoding_string (const char *string) { int str; diff --git a/tools/qfcc/source/stub.c b/tools/qfcc/source/stub.c index 4a0315d4a..12b98e1e6 100644 --- a/tools/qfcc/source/stub.c +++ b/tools/qfcc/source/stub.c @@ -32,7 +32,7 @@ pr_info_t pr; type_t type_Class; type_t type_SEL; type_t type_id; -__attribute__((const)) string_t ReuseString (const char *str) {return 0;} +__attribute__((const)) pr_string_t ReuseString (const char *str) {return 0;} __attribute__((const)) codespace_t *codespace_new (void) {return 0;} void codespace_addcode (codespace_t *codespace, struct dstatement_s *code, int size) {} __attribute__((const)) int function_parms (function_t *f, byte *parm_size) {return 0;} diff --git a/tools/qfcc/source/switch.c b/tools/qfcc/source/switch.c index 190d92a1b..f40d48d6d 100644 --- a/tools/qfcc/source/switch.c +++ b/tools/qfcc/source/switch.c @@ -408,7 +408,7 @@ switch_expr (switch_block_t *switch_block, expr_t *break_label, expr_t *default_expr; int num_labels = 0; int saved_line = pr.source_line; - string_t saved_file = pr.source_file; + pr_string_t saved_file = pr.source_file; pr.source_line = sw_val->line = switch_block->test->line; pr.source_file = sw_val->file = switch_block->test->file; diff --git a/tools/qfcc/source/value.c b/tools/qfcc/source/value.c index db98cd60a..cd0af3d54 100644 --- a/tools/qfcc/source/value.c +++ b/tools/qfcc/source/value.c @@ -60,7 +60,7 @@ typedef struct { def_t *def; union { - string_t string_val; + pr_string_t string_val; float float_val; float vector_val[3]; int entity_val; diff --git a/tools/qfcc/test/test-harness.c b/tools/qfcc/test/test-harness.c index 42b6a9935..b73b0916f 100644 --- a/tools/qfcc/test/test-harness.c +++ b/tools/qfcc/test/test-harness.c @@ -261,7 +261,7 @@ main (int argc, char **argv) dfunction_t *dfunc; func_t main_func = 0; const char *name = "progs.dat"; - string_t *pr_argv; + pr_string_t *pr_argv; int pr_argc = 1, i; i = parse_options (argc, argv); From 978d6fd3e8957b09e19aa3f5d8ad28573617abeb Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 12:24:43 +0900 Subject: [PATCH 135/360] [gamecode] Macro-ize the progs type names Now they'll never get out of sync again :) --- include/QF/Makemodule.am | 3 +- include/QF/progs/pr_comp.h | 18 ++---------- include/QF/progs/pr_type_names.h | 49 ++++++++++++++++++++++++++++++++ libs/gamecode/pr_opcode.c | 25 ++++++++++++++++ libs/gamecode/pr_v6p_opcode.c | 38 ------------------------- 5 files changed, 78 insertions(+), 55 deletions(-) create mode 100644 include/QF/progs/pr_type_names.h diff --git a/include/QF/Makemodule.am b/include/QF/Makemodule.am index 4f5aa35c9..76265bd70 100644 --- a/include/QF/Makemodule.am +++ b/include/QF/Makemodule.am @@ -135,7 +135,8 @@ include_qf_progs = \ include/QF/pr_comp.h \ include/QF/pr_debug.h \ include/QF/pr_obj.h \ - include/QF/pr_type.h + include/QF/pr_type.h \ + include/QF/pr_type_names.h include_qf_scene = \ include/QF/scene/entity.h \ diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 7b097cda1..4fffa8792 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -51,23 +51,9 @@ PR_VEC_TYPE (pr_ulong_t, pr_ulvec4_t, 4); PR_VEC_TYPE (double, pr_dvec2_t, 2); PR_VEC_TYPE (double, pr_dvec4_t, 4); +#define EV_TYPE(type) ev_##type, typedef enum { - ev_void, - ev_string, - ev_float, - ev_vector, - ev_entity, - ev_field, - ev_func, - ev_pointer, // end of v6 types - ev_quat, - ev_integer, - ev_uinteger, - ev_short, // value is embedded in the opcode - ev_double, - ev_long, - ev_ulong, - +#include "QF/progs/pr_type_names.h" ev_invalid, // invalid type. used for instruction checking ev_type_count // not a type, gives number of types } etype_t; diff --git a/include/QF/progs/pr_type_names.h b/include/QF/progs/pr_type_names.h new file mode 100644 index 000000000..2e0ae9576 --- /dev/null +++ b/include/QF/progs/pr_type_names.h @@ -0,0 +1,49 @@ +/* + pr_type_names.h + + Progs type names + + Copyright (C) 1996-1997 Id Software, Inc. + Copyright (C) 2022 Bill Currie + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + +*/ + +#ifndef EV_TYPE +#define EV_TYPE(event) +#endif + +EV_TYPE(void) +EV_TYPE(string) +EV_TYPE(float) +EV_TYPE(vector) +EV_TYPE(entity) +EV_TYPE(field) +EV_TYPE(func) +EV_TYPE(pointer) // end of v6 types +EV_TYPE(quat) +EV_TYPE(integer) +EV_TYPE(uinteger) +EV_TYPE(short) // value is embedded in the opcode +EV_TYPE(double) +EV_TYPE(long) +EV_TYPE(ulong) + +#undef EV_TYPE diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index add538502..1d725d21c 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -33,6 +33,31 @@ #include "QF/progs.h" +VISIBLE const pr_ushort_t pr_type_size[ev_type_count] = { + 1, // ev_void + 1, // ev_string + 1, // ev_float + 3, // ev_vector + 1, // ev_entity + 1, // ev_field + 1, // ev_func + 1, // ev_pointer + 4, // ev_quat + 1, // ev_integer + 1, // ev_uinteger + 0, // ev_short value in opcode + 2, // ev_double + 2, // ev_long + 2, // ev_ulong + 0, // ev_invalid not a valid/simple type +}; + +#define EV_TYPE(type) #type, +VISIBLE const char * const pr_type_name[ev_type_count] = { +#include "QF/progs/pr_type_names.h" + "invalid", +}; + const opcode_t pr_opcodes[512] = { #include "libs/gamecode/pr_opcode.cinc" }; diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index 6163050eb..560d14668 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -44,44 +44,6 @@ #include "compat.h" -VISIBLE const pr_ushort_t pr_type_size[ev_type_count] = { - 1, // ev_void - 1, // ev_string - 1, // ev_float - 3, // ev_vector - 1, // ev_entity - 1, // ev_field - 1, // ev_func - 1, // ev_pointer - 4, // ev_quat - 1, // ev_integer - 1, // ev_uinteger - 0, // ev_short value in opcode - 2, // ev_double - 2, // ev_long - 2, // ev_ulong - 0, // ev_invalid not a valid/simple type -}; - -VISIBLE const char * const pr_type_name[ev_type_count] = { - "void", - "string", - "float", - "vector", - "entity", - "field", - "function", - "pointer", - "quaternion", - "integer", - "uinteger", - "short", - "double", - "long", - "ulong", - "invalid", -}; - // default format is "%Ga, %Gb, %gc" // V global_string, contents, void // G global_string, contents From cfe7c44df050018ebc150f5af68b76a2aa417d98 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 13:21:06 +0900 Subject: [PATCH 136/360] [gamecode] Rename ev_integer to ev_int And other related fields so integer is now int (and uinteger is uint). I really don't know why I went with integer in the first place, but this will make using macros easier for dealing with types. --- include/QF/progs.h | 54 +-- include/QF/progs/pr_comp.h | 4 +- include/QF/progs/pr_type_names.h | 4 +- libs/gamecode/opcodes.py | 38 +- libs/gamecode/pr_debug.c | 50 +-- libs/gamecode/pr_exec.c | 86 ++-- libs/gamecode/pr_opcode.c | 4 +- libs/gamecode/pr_parse.c | 10 +- libs/gamecode/pr_v6p_opcode.c | 276 ++++++------ libs/gib/bi_gib.c | 2 +- libs/ruamoko/pr_cmds.c | 10 +- libs/ruamoko/rua_hash.c | 6 +- libs/ruamoko/rua_obj.c | 6 +- libs/video/renderer/vulkan/vkgen/vktype.r | 4 +- nq/include/sv_progs.h | 2 +- nq/source/sv_progs.c | 6 +- nq/source/world.c | 6 +- qw/include/sv_progs.h | 2 +- qw/source/sv_progs.c | 6 +- qw/source/sv_user.c | 4 +- qw/source/world.c | 6 +- ruamoko/cl_menu/plistmenu.r | 2 +- ruamoko/include/types.h | 4 +- ruamoko/qwaq/debugger/typeencodings.r | 2 +- tools/qfcc/include/expr.h | 32 +- tools/qfcc/include/obj_file.h | 8 +- tools/qfcc/include/qfcc.h | 2 +- tools/qfcc/include/type.h | 8 +- tools/qfcc/include/value.h | 4 +- tools/qfcc/source/class.c | 48 +- tools/qfcc/source/constfold.c | 186 ++++---- tools/qfcc/source/debug.c | 4 +- tools/qfcc/source/def.c | 5 +- tools/qfcc/source/dot_expr.c | 12 +- tools/qfcc/source/dot_type.c | 2 +- tools/qfcc/source/dump_globals.c | 4 +- tools/qfcc/source/expr.c | 150 +++---- tools/qfcc/source/expr_binary.c | 524 +++++++++++----------- tools/qfcc/source/expr_bool.c | 10 +- tools/qfcc/source/function.c | 6 +- tools/qfcc/source/method.c | 16 +- tools/qfcc/source/obj_file.c | 8 +- tools/qfcc/source/obj_type.c | 2 +- tools/qfcc/source/opcodes.c | 6 +- tools/qfcc/source/pragma.c | 2 +- tools/qfcc/source/qc-lex.l | 12 +- tools/qfcc/source/qc-parse.y | 6 +- tools/qfcc/source/qfcc.c | 8 +- tools/qfcc/source/qp-lex.l | 6 +- tools/qfcc/source/qp-parse.y | 8 +- tools/qfcc/source/reloc.c | 6 +- tools/qfcc/source/shared.c | 2 +- tools/qfcc/source/statements.c | 40 +- tools/qfcc/source/struct.c | 12 +- tools/qfcc/source/switch.c | 42 +- tools/qfcc/source/type.c | 64 ++- tools/qfcc/source/value.c | 90 ++-- tools/qfcc/test/double-alias.r | 10 +- tools/qfcc/test/typedef.r | 2 +- 59 files changed, 969 insertions(+), 972 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index f8c8d42b0..f9ae57c63 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -416,29 +416,29 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ */ #define G_DOUBLE(p,o) (*(double *) ((p)->pr_globals + o)) -/** Access an integer global. Can be assigned to. +/** Access an int global. Can be assigned to. \par QC type: - \c integer + \c int \param p pointer to ::progs_t VM struct \param o offset into global data space \return int lvalue \hideinitializer */ -#define G_INT(p,o) G_var (p, o, integer) +#define G_INT(p,o) G_var (p, o, int) -/** Access an unsigned integer global. Can be assigned to. +/** Access an unsigned int global. Can be assigned to. \par QC type: - \c uinteger + \c uint \param p pointer to ::progs_t VM struct \param o offset into global data space \return unsigned int lvalue \hideinitializer */ -#define G_UINT(p,o) G_var (p, o, uinteger) +#define G_UINT(p,o) G_var (p, o, uint) /** Access a vector global. Can be assigned to. @@ -632,29 +632,29 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ */ #define P_DOUBLE(p,n) P_PACKED(p, double, n) -/** Access an integer parameter. Can be assigned to. +/** Access an int parameter. Can be assigned to. \par QC type: - \c integer + \c int \param p pointer to ::progs_t VM struct \param n parameter number (0-7) \return int lvalue \hideinitializer */ -#define P_INT(p,n) P_var (p, n, integer) +#define P_INT(p,n) P_var (p, n, int) -/** Access an unsigned integer parameter. Can be assigned to. +/** Access an unsigned int parameter. Can be assigned to. \par QC type: - \c uinteger + \c uint \param p pointer to ::progs_t VM struct \param n parameter number (0-7) \return unsigned int lvalue \hideinitializer */ -#define P_UINT(p,n) P_var (p, n, uinteger) +#define P_UINT(p,n) P_var (p, n, uint) /** Access a vector parameter. Can be used any way a vec3_t variable can. @@ -850,24 +850,24 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ /** Access the VM function return value as a \c ::pr_int_t (AKA int32_t) \par QC type: - \c integer + \c int \param p pointer to ::progs_t VM struct \return ::pr_int_t lvalue \hideinitializer */ -#define R_INT(p) R_var (p, integer) +#define R_INT(p) R_var (p, int) /** Access the VM function return value as a \c ::pr_uint_t (AKA uint32_t) \par QC type: - \c uinteger + \c uint \param p pointer to ::progs_t VM struct \return ::pr_int_t lvalue \hideinitializer */ -#define R_UINT(p) R_var (p, uinteger) +#define R_UINT(p) R_var (p, uint) /** Access the VM function return value as a \c ::vec3_t vector. @@ -1036,29 +1036,29 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ */ #define E_DOUBLE(e,o) (*(double *) ((e)->v + o)) -/** Access an integer entity field. Can be assigned to. +/** Access an int entity field. Can be assigned to. \par QC type: - \c integer + \c int \param e pointer to the entity \param o field offset into entity data space \return int lvalue \hideinitializer */ -#define E_INT(e,o) E_var (e, o, integer) +#define E_INT(e,o) E_var (e, o, int) -/** Access an unsigned integer entity field. Can be assigned to. +/** Access an unsigned int entity field. Can be assigned to. \par QC type: - \c uinteger + \c uint \param e pointer to the entity \param o field offset into entity data space \return unsigned int lvalue \hideinitializer */ -#define E_UINT(e,o) E_var (e, o, uinteger) +#define E_UINT(e,o) E_var (e, o, uint) /** Access a vector entity field. Can be used any way a vec3_t variable can. @@ -1452,14 +1452,14 @@ void PR_FreeTempStrings (progs_t *pr);
  • \c '@' \c id Not yet implemented. Silently ignored.
  • \c 'e' \c entity Prints the edict number of the given entity ("%i") -
  • \c 'i' \c integer Print a integer value. ("%i") +
  • \c 'i' \c int Print a int value. ("%i")
  • \c 'f' \c float Print a float value. ("%f")
  • \c 'g' \c float Print a float value. ("%f")
  • \c 'p' \c void * Print a pointer value. ("%#x")
  • \c 's' \c string Print a string value. ("%s")
  • \c 'v' \c vector Print a vector value. ("'%g %g %g'")
  • \c 'q' \c quaternion Print a quaternion value. ("'%g %g %g %g'") -
  • \c 'x' \c uinteger Print an unsigned integer value. ("%x") +
  • \c 'x' \c uint Print an unsigned int value. ("%x")
@@ -1528,7 +1528,7 @@ void *PR_Resources_Find (progs_t *pr, const char *name); /** \name Resource Map support These macros can be used to create functions for mapping C resources - to QuakeC integer handles. + to QuakeC int handles. Valid handles are always negative. @@ -1731,8 +1731,8 @@ typedef struct type_view_s { type_view_func func_view; type_view_func pointer_view; type_view_func quat_view; - type_view_func integer_view; - type_view_func uinteger_view; + type_view_func int_view; + type_view_func uint_view; type_view_func short_view; type_view_func double_view; type_view_func long_view; diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 4fffa8792..9dbaea8db 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -524,9 +524,9 @@ typedef union pr_type_u { pr_uint_t entity_var; float vector_var; // really [3], but this structure must be 32 bits float quat_var; // really [4], but this structure must be 32 bits - pr_int_t integer_var; + pr_int_t int_var; pr_ptr_t pointer_var; - pr_uint_t uinteger_var; + pr_uint_t uint_var; } pr_type_t; typedef struct pr_va_list_s { diff --git a/include/QF/progs/pr_type_names.h b/include/QF/progs/pr_type_names.h index 2e0ae9576..ff190f2cd 100644 --- a/include/QF/progs/pr_type_names.h +++ b/include/QF/progs/pr_type_names.h @@ -39,8 +39,8 @@ EV_TYPE(field) EV_TYPE(func) EV_TYPE(pointer) // end of v6 types EV_TYPE(quat) -EV_TYPE(integer) -EV_TYPE(uinteger) +EV_TYPE(int) +EV_TYPE(uint) EV_TYPE(short) // value is embedded in the opcode EV_TYPE(double) EV_TYPE(long) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 4b123ce19..8734bb03c 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -48,8 +48,8 @@ branch_fmt = [ ] compare_ccc = [ "eq", "lt", "gt", None, "ne", "ge", "le", None] type_tt = ['I', 'F', 'L', 'D'] -etype_tt = ["ev_integer", "ev_float", "ev_long", "ev_double"] -unsigned_t = ["ev_uinteger", "ev_ulong"] +etype_tt = ["ev_int", "ev_float", "ev_long", "ev_double"] +unsigned_t = ["ev_uint", "ev_ulong"] float_t = ["ev_float", "ev_double"] all_formats = { @@ -58,7 +58,7 @@ all_formats = { "opname": "all", "format": "%Ga, %gc", "widths": "{ss+1}, 0, 1", - "types": "ev_integer, ev_integer, ev_integer", + "types": "ev_int, ev_int, ev_int", } any_formats = { "opcode": "OP_ANY_{ss+1}", @@ -66,7 +66,7 @@ any_formats = { "opname": "any", "format": "%Ga, %gc", "widths": "{ss+1}, 0, 1", - "types": "ev_integer, ev_integer, ev_integer", + "types": "ev_int, ev_int, ev_int", } bitops_formats = { "opcode": "OP_{op_bit[oo].upper()}_{bit_type[t]}_{ss+1}", @@ -78,7 +78,7 @@ bitops_formats = { "args": { "op_bit": ["bitand", "bitor", "bitxor", "bitnot"], "bit_type": ["I", "L"], - "bit_types": ["ev_integer", "ev_long"], + "bit_types": ["ev_int", "ev_long"], "bit_fmt": [ "%Ga, %Gb, %gc", "%Ga, %Gb, %gc", @@ -93,7 +93,7 @@ branch_formats = { "opname": "{op_cond[c*4+cc]}", "format": "{cond_fmt[c*4+cc]}{branch_fmt[0]}", "widths": "{cond_widths[c*4+cc]}", - "types": "ev_void, ev_void, ev_integer", + "types": "ev_void, ev_void, ev_int", "args": { "op_mode": "ABCD", "op_cond": ["ifz", "ifb", "ifa", None, @@ -134,7 +134,7 @@ compare_formats = { "mnemonic": "{op_cmp[ccc]}.{cmp_type[tt]}", "opname": "{op_cmp[ccc]}", "widths": "{ss+1}, {ss+1}, {ss+1}", - "types": "{cmp_types[tt]}, {cmp_types[tt]}, ev_integer", + "types": "{cmp_types[tt]}, {cmp_types[tt]}, ev_int", "args": { "op_cmp": compare_ccc, "cmp_type": type_tt, @@ -146,7 +146,7 @@ compare2_formats = { "mnemonic": "{op_cmp[ccc]}.{cmp_type[t]}", "opname": "{op_cmp[ccc]}", "widths": "{ss+1}, {ss+1}, {ss+1}", - "types": "{cmp_types[t]}, {cmp_types[t]}, ev_integer", + "types": "{cmp_types[t]}, {cmp_types[t]}, ev_int", "args": { "op_cmp": compare_ccc, "cmp_type": ['u', 'U'], @@ -228,7 +228,7 @@ memset_formats = { "opname": "memset", "format": "{memset_fmt[oo]}", "widths": "0, 0, 0", - "types": "ev_integer, ev_void, ev_void", + "types": "ev_int, ev_void, ev_void", "args": { "op_memset": ["i", "p", "pi", None], "memset_fmt": ["%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc", None], @@ -240,7 +240,7 @@ move_formats = { "opname": "memset", "format": "{move_fmt[oo]}", "widths": "0, 0, 0", - "types": "ev_integer, ev_void, ev_void", + "types": "ev_int, ev_void, ev_void", "args": { "op_move": ["i", "p", "pi", None], "move_fmt": ["%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc", None], @@ -252,7 +252,7 @@ none_formats = { "opname": "none", "format": "%Ga, %gc", "widths": "{ss+1}, 0, 1", - "types": "ev_integer, ev_invalid, ev_integer", + "types": "ev_int, ev_invalid, ev_int", } push_formats = { "opcode": "OP_PUSH_{op_mode[mm]}_{ss+1}", @@ -325,7 +325,7 @@ shiftops_formats = { "op_shift": ["shl", "asr", "shl", "shr"], "shift_type": ['I', 'L', 'u', 'U'], "shift_types": [ - ["ev_integer", "ev_uinteger"], + ["ev_int", "ev_uint"], ["ev_long", "ev_ulong"], ], }, @@ -393,14 +393,14 @@ string_formats = { "%Ga, %gc", ], "str_types": [ - "ev_string, ev_string, ev_integer", - "ev_string, ev_string, ev_integer", - "ev_string, ev_string, ev_integer", + "ev_string, ev_string, ev_int", + "ev_string, ev_string, ev_int", + "ev_string, ev_string, ev_int", "ev_string, ev_string, ev_string", - "ev_string, ev_string, ev_integer", - "ev_string, ev_string, ev_integer", - "ev_string, ev_string, ev_integer", - "ev_string, ev_invalid, ev_integer", + "ev_string, ev_string, ev_int", + "ev_string, ev_string, ev_int", + "ev_string, ev_string, ev_int", + "ev_string, ev_invalid, ev_int", ], }, } diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 4b4b23d05..9e0b1b363 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -137,9 +137,9 @@ static void pr_debug_pointer_view (qfot_type_t *type, pr_type_t *value, void *_data); static void pr_debug_quat_view (qfot_type_t *type, pr_type_t *value, void *_data); -static void pr_debug_integer_view (qfot_type_t *type, pr_type_t *value, +static void pr_debug_int_view (qfot_type_t *type, pr_type_t *value, void *_data); -static void pr_debug_uinteger_view (qfot_type_t *type, pr_type_t *value, +static void pr_debug_uint_view (qfot_type_t *type, pr_type_t *value, void *_data); static void pr_debug_short_view (qfot_type_t *type, pr_type_t *value, void *_data); @@ -170,8 +170,8 @@ static type_view_t raw_type_view = { pr_debug_func_view, pr_debug_pointer_view, pr_debug_quat_view, - pr_debug_integer_view, - pr_debug_uinteger_view, + pr_debug_int_view, + pr_debug_uint_view, pr_debug_short_view, pr_debug_double_view, pr_debug_long_view, @@ -269,7 +269,7 @@ pr_debug_type_size (const progs_t *pr, const qfot_type_t *type) } return size; case ty_enum: - return pr_type_size[ev_integer]; + return pr_type_size[ev_int]; case ty_array: aux_type = &G_STRUCT (pr, qfot_type_t, type->array.type); size = pr_debug_type_size (pr, aux_type); @@ -356,7 +356,7 @@ parse_expression (progs_t *pr, const char *expr, int conditional) goto error; if (!Script_GetToken (es, 1)) goto error; - pr->wp_val.integer_var = strtol (es->token->str, &e, 0); + pr->wp_val.int_var = strtol (es->token->str, &e, 0); if (e == es->token->str) goto error; if (*e == '.' || *e == 'e' || *e == 'E') @@ -404,7 +404,7 @@ pr_debug_clear (progs_t *pr, void *data) pr->watch = 0; pr->wp_conditional = 0; - pr->wp_val.integer_var = 0; + pr->wp_val.int_var = 0; for (int i = 0; i < ev_type_count; i++ ) { res->type_encodings[i] = &res->void_type; @@ -1056,11 +1056,11 @@ value_string (pr_debug_data_t *data, qfot_type_t *type, pr_type_t *value) case ev_quat: raw_type_view.quat_view (type, value, data); break; - case ev_integer: - raw_type_view.integer_view (type, value, data); + case ev_int: + raw_type_view.int_view (type, value, data); break; - case ev_uinteger: - raw_type_view.uinteger_view (type, value, data); + case ev_uint: + raw_type_view.uint_view (type, value, data); break; case ev_short: raw_type_view.short_view (type, value, data); @@ -1242,9 +1242,9 @@ pr_debug_float_view (qfot_type_t *type, pr_type_t *value, void *_data) dstring_t *dstr = data->dstr; if (data->pr->progs->version == PROG_ID_VERSION - && ISDENORM (value->integer_var) - && value->uinteger_var != 0x80000000) { - dasprintf (dstr, "<%08x>", value->integer_var); + && ISDENORM (value->int_var) + && value->uint_var != 0x80000000) { + dasprintf (dstr, "<%08x>", value->int_var); } else { dasprintf (dstr, "%.9g", value->float_var); } @@ -1284,12 +1284,12 @@ pr_debug_field_view (qfot_type_t *type, pr_type_t *value, void *_data) __auto_type data = (pr_debug_data_t *) _data; progs_t *pr = data->pr; dstring_t *dstr = data->dstr; - pr_def_t *def = PR_FieldAtOfs (pr, value->integer_var); + pr_def_t *def = PR_FieldAtOfs (pr, value->int_var); if (def) { dasprintf (dstr, ".%s", PR_GetString (pr, def->name)); } else { - dasprintf (dstr, ".<$%04x>", value->integer_var); + dasprintf (dstr, ".<$%04x>", value->int_var); } } @@ -1316,7 +1316,7 @@ pr_debug_pointer_view (qfot_type_t *type, pr_type_t *value, void *_data) __auto_type data = (pr_debug_data_t *) _data; progs_t *pr = data->pr; dstring_t *dstr = data->dstr; - pr_ptr_t offset = value->integer_var; + pr_ptr_t offset = value->int_var; pr_ptr_t offs = offset; pr_def_t *def = 0; @@ -1342,21 +1342,21 @@ pr_debug_quat_view (qfot_type_t *type, pr_type_t *value, void *_data) } static void -pr_debug_integer_view (qfot_type_t *type, pr_type_t *value, void *_data) +pr_debug_int_view (qfot_type_t *type, pr_type_t *value, void *_data) { __auto_type data = (pr_debug_data_t *) _data; dstring_t *dstr = data->dstr; - dasprintf (dstr, "%d", value->integer_var); + dasprintf (dstr, "%d", value->int_var); } static void -pr_debug_uinteger_view (qfot_type_t *type, pr_type_t *value, void *_data) +pr_debug_uint_view (qfot_type_t *type, pr_type_t *value, void *_data) { __auto_type data = (pr_debug_data_t *) _data; dstring_t *dstr = data->dstr; - dasprintf (dstr, "$%08x", value->uinteger_var); + dasprintf (dstr, "$%08x", value->uint_var); } static void @@ -1365,7 +1365,7 @@ pr_debug_short_view (qfot_type_t *type, pr_type_t *value, void *_data) __auto_type data = (pr_debug_data_t *) _data; dstring_t *dstr = data->dstr; - dasprintf (dstr, "%04x", (short)value->integer_var); + dasprintf (dstr, "%04x", (short)value->int_var); } static void @@ -1468,7 +1468,7 @@ PR_Debug_Watch (progs_t *pr, const char *expr) (int) (intptr_t) (pr->watch - pr->pr_globals)); if (pr->wp_conditional) Sys_Printf (" if new val == %d\n", - pr->wp_val.integer_var); + pr->wp_val.int_var); } else { Sys_Printf (" none active\n"); } return; @@ -1481,7 +1481,7 @@ PR_Debug_Watch (progs_t *pr, const char *expr) if (pr->watch) { Sys_Printf ("watchpoint set to [%d]\n", PR_SetPointer (pr, pr->watch)); if (pr->wp_conditional) - Sys_Printf (" if new val == %d\n", pr->wp_val.integer_var); + Sys_Printf (" if new val == %d\n", pr->wp_val.int_var); } else { Sys_Printf ("watchpoint cleared\n"); } @@ -1672,7 +1672,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) { edict_t *ed = 0; opval = pr->pr_globals[s->a].entity_var; - parm_ind = pr->pr_globals[s->b].uinteger_var; + parm_ind = pr->pr_globals[s->b].uint_var; if (parm_ind < pr->progs->entityfields && opval > 0 && opval < pr->pr_edict_area_size) { diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 53964982f..d0f94d8fb 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -282,7 +282,7 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) if (pr_deadbeef_locals->int_val) for (i = f->parm_start; i < f->parm_start + f->locals; i++) - pr->pr_globals[i].integer_var = 0xdeadbeef; + pr->pr_globals[i].int_var = 0xdeadbeef; // copy parameters if (f->numparms >= 0) { @@ -297,8 +297,8 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) copy_param (dstParams[i], pr->pr_params[i], f->parm_size[i].size); } copy_args = pr->pr_argc - i; - argc->integer_var = copy_args; - argv->integer_var = dstParams[i] - pr->pr_globals; + argc->int_var = copy_args; + argv->int_var = dstParams[i] - pr->pr_globals; if (i < MAX_PARMS) { memcpy (dstParams[i], pr->pr_params[i], (copy_args * pr->pr_param_size) * sizeof (pr_type_t)); @@ -461,7 +461,7 @@ static inline void pr_memset (pr_type_t *dst, int val, int count) { while (count-- > 0) { - (*dst++).integer_var = val; + (*dst++).int_var = val; } } @@ -783,10 +783,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREP_P_v6p: pointer = OPB(int); if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } ptr = pr->pr_globals + pointer; - ptr->integer_var = OPA(int); + ptr->int_var = OPA(int); break; case OP_STOREP_V_v6p: pointer = OPB(int); @@ -857,7 +857,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) "field in an edict"); } fldofs = OPA(uint) + OPB(int); - OPC(int) = pr->pr_edict_area[fldofs].integer_var; + OPC(int) = pr->pr_edict_area[fldofs].int_var; break; case OP_LOAD_V_v6p: if (pr_boundscheck->int_val) { @@ -905,10 +905,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_LOADB_P_v6p: pointer = OPA(int) + OPB(int); if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } ptr = pr->pr_globals + pointer; - OPC(int) = ptr->integer_var; + OPC(int) = ptr->int_var; break; case OP_LOADB_V_v6p: pointer = OPA(int) + OPB(int); @@ -944,10 +944,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_LOADBI_P_v6p: pointer = OPA(int) + (short) st->b; if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } ptr = pr->pr_globals + pointer; - OPC(int) = ptr->integer_var; + OPC(int) = ptr->int_var; break; case OP_LOADBI_V_v6p: pointer = OPA(int) + (short) st->b; @@ -993,10 +993,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREB_P_v6p: pointer = OPB(int) + OPC(int); if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } ptr = pr->pr_globals + pointer; - ptr->integer_var = OPA(int); + ptr->int_var = OPA(int); break; case OP_STOREB_V_v6p: pointer = OPB(int) + OPC(int); @@ -1032,10 +1032,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREBI_P_v6p: pointer = OPB(int) + (short) st->c; if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } ptr = pr->pr_globals + pointer; - ptr->integer_var = OPA(int); + ptr->int_var = OPA(int); break; case OP_STOREBI_V_v6p: pointer = OPB(int) + (short) st->c; @@ -1075,7 +1075,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 1); } - stk->integer_var = OPA(int); + stk->int_var = OPA(int); *pr->globals.stack = stack; } break; @@ -1118,10 +1118,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 1); - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } - stk->integer_var = ptr->integer_var; + stk->int_var = ptr->int_var; *pr->globals.stack = stack; } break; @@ -1135,7 +1135,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 3); - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } VectorCopy (&ptr->vector_var, &stk->vector_var); @@ -1176,10 +1176,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 1); - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } - stk->integer_var = ptr->integer_var; + stk->int_var = ptr->int_var; *pr->globals.stack = stack; } break; @@ -1193,7 +1193,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 3); - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } VectorCopy (&ptr->vector_var, &stk->vector_var); @@ -1231,7 +1231,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 1); } - OPA(int) = stk->integer_var; + OPA(int) = stk->int_var; *pr->globals.stack = stack + 1; } break; @@ -1274,10 +1274,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 1); - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } - ptr->integer_var = stk->integer_var; + ptr->int_var = stk->int_var; *pr->globals.stack = stack + 1; } break; @@ -1291,7 +1291,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 3); - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } VectorCopy (&stk->vector_var, &ptr->vector_var); @@ -1332,10 +1332,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 1); - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } - ptr->integer_var = stk->integer_var; + ptr->int_var = stk->int_var; *pr->globals.stack = stack + 1; } break; @@ -1349,7 +1349,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 3); - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } VectorCopy (&stk->vector_var, &ptr->vector_var); @@ -1426,10 +1426,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_JUMPB_v6p: pointer = st->a + OPB(int); if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_integer); + PR_BoundsCheck (pr, pointer, ev_int); } ptr = pr->pr_globals + pointer; - pointer = ptr->integer_var; + pointer = ptr->int_var; if (pr_boundscheck->int_val && (pointer >= pr->progs->numstatements)) { PR_RunError (pr, "Invalid jump destination"); @@ -1695,8 +1695,8 @@ op_call: OPC(float) = OPA(double) < OPB(double); break; case OP_NOT_D_v6p: - OPC(int) = (op_a[0].integer_var - || (op_a[1].integer_var & ~0x80000000u)); + OPC(int) = (op_a[0].int_var + || (op_a[1].int_var & ~0x80000000u)); break; case OP_EQ_D_v6p: OPC(int) = OPA(double) == OPB(double); @@ -1730,17 +1730,17 @@ op_call: default: PR_RunError (pr, "Bad opcode %i", st->op & ~OP_BREAK); } - if (pr->watch && pr->watch->integer_var != old_val.integer_var) { + if (pr->watch && pr->watch->int_var != old_val.int_var) { if (!pr->wp_conditional - || pr->watch->integer_var == pr->wp_val.integer_var) { + || pr->watch->int_var == pr->wp_val.int_var) { if (pr->debug_handler) { pr->debug_handler (prd_watchpoint, 0, pr->debug_data); } else { PR_RunError (pr, "watchpoint hit: %d -> %d", - old_val.integer_var, pr->watch->integer_var); + old_val.int_var, pr->watch->int_var); } } - old_val.integer_var = pr->watch->integer_var; + old_val.int_var = pr->watch->int_var; } } exit_program: @@ -3355,7 +3355,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) int think = pr->fields.think + self; double time = *pr->globals.dtime + 0.1; *(double *) (&pr->pr_edict_area[nextthink]) = time; - pr->pr_edict_area[frame].integer_var = OPA(int); + pr->pr_edict_area[frame].int_var = OPA(int); pr->pr_edict_area[think].func_var = op_b->func_var; } break; @@ -3386,7 +3386,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) int think = pr->fields.think + self; double time = *pr->globals.dtime + OPC(double); *(double *) (&pr->pr_edict_area[nextthink]) = time; - pr->pr_edict_area[frame].integer_var = OPA(int); + pr->pr_edict_area[frame].int_var = OPA(int); pr->pr_edict_area[think].func_var = op_b->func_var; } break; @@ -3440,17 +3440,17 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) default: PR_RunError (pr, "Bad opcode o%03o", st->op & OP_MASK); } - if (pr->watch && pr->watch->integer_var != old_val.integer_var) { + if (pr->watch && pr->watch->int_var != old_val.int_var) { if (!pr->wp_conditional - || pr->watch->integer_var == pr->wp_val.integer_var) { + || pr->watch->int_var == pr->wp_val.int_var) { if (pr->debug_handler) { pr->debug_handler (prd_watchpoint, 0, pr->debug_data); } else { PR_RunError (pr, "watchpoint hit: %d -> %d", - old_val.integer_var, pr->watch->integer_var); + old_val.int_var, pr->watch->int_var); } } - old_val.integer_var = pr->watch->integer_var; + old_val.int_var = pr->watch->int_var; } } exit_program: diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index 1d725d21c..0f1cb1258 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -43,8 +43,8 @@ VISIBLE const pr_ushort_t pr_type_size[ev_type_count] = { 1, // ev_func 1, // ev_pointer 4, // ev_quat - 1, // ev_integer - 1, // ev_uinteger + 1, // ev_int + 1, // ev_uint 0, // ev_short value in opcode 2, // ev_double 2, // ev_long diff --git a/libs/gamecode/pr_parse.c b/libs/gamecode/pr_parse.c index 8b4c2d728..33ab39d3c 100644 --- a/libs/gamecode/pr_parse.c +++ b/libs/gamecode/pr_parse.c @@ -79,7 +79,7 @@ PR_UglyValueString (progs_t *pr, etype_t type, pr_type_t *val, dstring_t *line) dsprintf (line, "%s", PR_GetString (pr, f->name)); break; case ev_field: - def = PR_FieldAtOfs (pr, val->integer_var); + def = PR_FieldAtOfs (pr, val->int_var); dsprintf (line, "%s", PR_GetString (pr, def->name)); break; case ev_void: @@ -88,8 +88,8 @@ PR_UglyValueString (progs_t *pr, etype_t type, pr_type_t *val, dstring_t *line) case ev_float: dsprintf (line, "%.9g", val->float_var); break; - case ev_integer: - dsprintf (line, "%d", val->integer_var); + case ev_int: + dsprintf (line, "%d", val->int_var); break; case ev_vector: dsprintf (line, "%.9g %.9g %.9g", VectorExpand (&val->vector_var)); @@ -132,7 +132,7 @@ ED_EntityDict (progs_t *pr, edict_t *ed) // if the value is still all 0, skip the field type = d->type & ~DEF_SAVEGLOBAL; for (j = 0; j < pr_type_size[type]; j++) - if (v[j].integer_var) + if (v[j].int_var) break; if (j == pr_type_size[type]) continue; @@ -257,7 +257,7 @@ ED_ParseEpair (progs_t *pr, pr_type_t *base, pr_def_t *key, const char *s) Sys_Printf ("Can't find field %s\n", s); return false; } - d->integer_var = G_INT (pr, def->ofs); + d->int_var = G_INT (pr, def->ofs); break; case ev_func: diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index 560d14668..c61821852 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -183,109 +183,109 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_EQ_D_v6p] = {"==", "eq.d", - ev_double, ev_double, ev_integer, + ev_double, ev_double, ev_int, PROG_V6P_VERSION, }, [OP_EQ_F_v6p] = {"==", "eq.f", - ev_float, ev_float, ev_integer, + ev_float, ev_float, ev_int, PROG_ID_VERSION, }, [OP_EQ_V_v6p] = {"==", "eq.v", - ev_vector, ev_vector, ev_integer, + ev_vector, ev_vector, ev_int, PROG_ID_VERSION, }, [OP_EQ_Q_v6p] = {"==", "eq.q", - ev_quat, ev_quat, ev_integer, + ev_quat, ev_quat, ev_int, PROG_V6P_VERSION, }, [OP_EQ_S_v6p] = {"==", "eq.s", - ev_string, ev_string, ev_integer, + ev_string, ev_string, ev_int, PROG_ID_VERSION, }, [OP_EQ_E_v6p] = {"==", "eq.e", - ev_entity, ev_entity, ev_integer, + ev_entity, ev_entity, ev_int, PROG_ID_VERSION, }, [OP_EQ_FN_v6p] = {"==", "eq.fn", - ev_func, ev_func, ev_integer, + ev_func, ev_func, ev_int, PROG_ID_VERSION, }, [OP_NE_D_v6p] = {"!=", "ne.d", - ev_double, ev_double, ev_integer, + ev_double, ev_double, ev_int, PROG_V6P_VERSION, }, [OP_NE_F_v6p] = {"!=", "ne.f", - ev_float, ev_float, ev_integer, + ev_float, ev_float, ev_int, PROG_ID_VERSION, }, [OP_NE_V_v6p] = {"!=", "ne.v", - ev_vector, ev_vector, ev_integer, + ev_vector, ev_vector, ev_int, PROG_ID_VERSION, }, [OP_NE_Q_v6p] = {"!=", "ne.q", - ev_quat, ev_quat, ev_integer, + ev_quat, ev_quat, ev_int, PROG_V6P_VERSION, }, [OP_NE_S_v6p] = {"!=", "ne.s", - ev_string, ev_string, ev_integer, + ev_string, ev_string, ev_int, PROG_ID_VERSION, }, [OP_NE_E_v6p] = {"!=", "ne.e", - ev_entity, ev_entity, ev_integer, + ev_entity, ev_entity, ev_int, PROG_ID_VERSION, }, [OP_NE_FN_v6p] = {"!=", "ne.fn", - ev_func, ev_func, ev_integer, + ev_func, ev_func, ev_int, PROG_ID_VERSION, }, [OP_LE_D_v6p] = {"<=", "le.d", - ev_double, ev_double, ev_integer, + ev_double, ev_double, ev_int, PROG_V6P_VERSION, }, [OP_LE_F_v6p] = {"<=", "le.f", - ev_float, ev_float, ev_integer, + ev_float, ev_float, ev_int, PROG_ID_VERSION, }, [OP_GE_D_v6p] = {">=", "ge.d", - ev_double, ev_double, ev_integer, + ev_double, ev_double, ev_int, PROG_V6P_VERSION, }, [OP_GE_F_v6p] = {">=", "ge.f", - ev_float, ev_float, ev_integer, + ev_float, ev_float, ev_int, PROG_ID_VERSION, }, [OP_LE_S_v6p] = {"<=", "le.s", - ev_string, ev_string, ev_integer, + ev_string, ev_string, ev_int, PROG_V6P_VERSION, }, [OP_GE_S_v6p] = {">=", "ge.s", - ev_string, ev_string, ev_integer, + ev_string, ev_string, ev_int, PROG_V6P_VERSION, }, [OP_LT_D_v6p] = {"<", "lt.d", - ev_double, ev_double, ev_integer, + ev_double, ev_double, ev_int, PROG_V6P_VERSION, }, [OP_LT_F_v6p] = {"<", "lt.f", - ev_float, ev_float, ev_integer, + ev_float, ev_float, ev_int, PROG_ID_VERSION, }, [OP_GT_D_v6p] = {">", "gt.d", - ev_double, ev_double, ev_integer, + ev_double, ev_double, ev_int, PROG_V6P_VERSION, }, [OP_GT_F_v6p] = {">", "gt.f", - ev_float, ev_float, ev_integer, + ev_float, ev_float, ev_int, PROG_ID_VERSION, }, [OP_LT_S_v6p] = {"<", "lt.s", - ev_string, ev_string, ev_integer, + ev_string, ev_string, ev_int, PROG_V6P_VERSION, }, [OP_GT_S_v6p] = {">", "gt.s", - ev_string, ev_string, ev_integer, + ev_string, ev_string, ev_int, PROG_V6P_VERSION, }, @@ -330,7 +330,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga.%Gb(%Ec), %gc", }, [OP_LOAD_I_v6p] = {".", "load.i", - ev_entity, ev_field, ev_integer, + ev_entity, ev_field, ev_int, PROG_V6P_VERSION, "%Ga.%Gb(%Ec), %gc", }, @@ -341,52 +341,52 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_LOADB_D_v6p] = {".", "loadb.d", - ev_pointer, ev_integer, ev_double, + ev_pointer, ev_int, ev_double, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_F_v6p] = {".", "loadb.f", - ev_pointer, ev_integer, ev_float, + ev_pointer, ev_int, ev_float, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_V_v6p] = {".", "loadb.v", - ev_pointer, ev_integer, ev_vector, + ev_pointer, ev_int, ev_vector, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_Q_v6p] = {".", "loadb.q", - ev_pointer, ev_integer, ev_quat, + ev_pointer, ev_int, ev_quat, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_S_v6p] = {".", "loadb.s", - ev_pointer, ev_integer, ev_string, + ev_pointer, ev_int, ev_string, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_ENT_v6p] = {".", "loadb.ent", - ev_pointer, ev_integer, ev_entity, + ev_pointer, ev_int, ev_entity, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_FLD_v6p] = {".", "loadb.fld", - ev_pointer, ev_integer, ev_field, + ev_pointer, ev_int, ev_field, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_FN_v6p] = {".", "loadb.fn", - ev_pointer, ev_integer, ev_func, + ev_pointer, ev_int, ev_func, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_I_v6p] = {".", "loadb.i", - ev_pointer, ev_integer, ev_integer, + ev_pointer, ev_int, ev_int, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_P_v6p] = {".", "loadb.p", - ev_pointer, ev_integer, ev_pointer, + ev_pointer, ev_int, ev_pointer, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, @@ -432,7 +432,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "*(%Ga + %sb), %gc", }, [OP_LOADBI_I_v6p] = {".", "loadbi.i", - ev_pointer, ev_short, ev_integer, + ev_pointer, ev_short, ev_int, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, @@ -494,7 +494,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, %gc", }, [OP_ADDRESS_I_v6p] = {"&", "address.i", - ev_integer, ev_invalid, ev_pointer, + ev_int, ev_invalid, ev_pointer, PROG_V6P_VERSION, "%Ga, %gc", }, @@ -505,7 +505,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_LEA_v6p] = {"&", "lea", - ev_pointer, ev_integer, ev_pointer, + ev_pointer, ev_int, ev_pointer, PROG_V6P_VERSION, "(%Ga + %Gb), %gc", }, @@ -516,22 +516,22 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_CONV_IF_v6p] = {"", "conv.if", - ev_integer, ev_invalid, ev_float, + ev_int, ev_invalid, ev_float, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_CONV_FI_v6p] = {"", "conv.fi", - ev_float, ev_invalid, ev_integer, + ev_float, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_CONV_ID_v6p] = {"", "conv.id", - ev_integer, ev_invalid, ev_double, + ev_int, ev_invalid, ev_double, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_CONV_DI_v6p] = {"", "conv.di", - ev_double, ev_invalid, ev_integer, + ev_double, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, @@ -587,7 +587,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, %gb", }, [OP_STORE_I_v6p] = {"=", "store.i", - ev_integer, ev_integer, ev_invalid, + ev_int, ev_int, ev_invalid, PROG_V6P_VERSION, "%Ga, %gb", }, @@ -638,7 +638,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, *%Gb", }, [OP_STOREP_I_v6p] = {".=", "storep.i", - ev_integer, ev_pointer, ev_invalid, + ev_int, ev_pointer, ev_invalid, PROG_V6P_VERSION, "%Ga, *%Gb", }, @@ -649,52 +649,52 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_STOREB_D_v6p] = {".=", "storeb.d", - ev_double, ev_pointer, ev_integer, + ev_double, ev_pointer, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_F_v6p] = {".=", "storeb.f", - ev_float, ev_pointer, ev_integer, + ev_float, ev_pointer, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_V_v6p] = {".=", "storeb.v", - ev_vector, ev_pointer, ev_integer, + ev_vector, ev_pointer, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_Q_v6p] = {".=", "storeb.q", - ev_quat, ev_pointer, ev_integer, + ev_quat, ev_pointer, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_S_v6p] = {".=", "storeb.s", - ev_string, ev_pointer, ev_integer, + ev_string, ev_pointer, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_ENT_v6p] = {".=", "storeb.ent", - ev_entity, ev_pointer, ev_integer, + ev_entity, ev_pointer, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_FLD_v6p] = {".=", "storeb.fld", - ev_field, ev_pointer, ev_integer, + ev_field, ev_pointer, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_FN_v6p] = {".=", "storeb.fn", - ev_func, ev_pointer, ev_integer, + ev_func, ev_pointer, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_I_v6p] = {".=", "storeb.i", - ev_integer, ev_pointer, ev_integer, + ev_int, ev_pointer, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_P_v6p] = {".=", "storeb.p", - ev_pointer, ev_pointer, ev_integer, + ev_pointer, ev_pointer, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, @@ -740,7 +740,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_I_v6p] = {".=", "storebi.i", - ev_integer, ev_pointer, ev_short, + ev_int, ev_pointer, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, @@ -763,73 +763,73 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_NOT_D_v6p] = {"!", "not.d", - ev_double, ev_invalid, ev_integer, + ev_double, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_NOT_F_v6p] = {"!", "not.f", - ev_float, ev_invalid, ev_integer, + ev_float, ev_invalid, ev_int, PROG_ID_VERSION, "%Ga, %gc", }, [OP_NOT_V_v6p] = {"!", "not.v", - ev_vector, ev_invalid, ev_integer, + ev_vector, ev_invalid, ev_int, PROG_ID_VERSION, "%Ga, %gc", }, [OP_NOT_Q_v6p] = {"!", "not.q", - ev_quat, ev_invalid, ev_integer, + ev_quat, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_NOT_S_v6p] = {"!", "not.s", - ev_string, ev_invalid, ev_integer, + ev_string, ev_invalid, ev_int, PROG_ID_VERSION, "%Ga, %gc", }, [OP_NOT_ENT_v6p] = {"!", "not.ent", - ev_entity, ev_invalid, ev_integer, + ev_entity, ev_invalid, ev_int, PROG_ID_VERSION, "%Ga, %gc", }, [OP_NOT_FN_v6p] = {"!", "not.fn", - ev_func, ev_invalid, ev_integer, + ev_func, ev_invalid, ev_int, PROG_ID_VERSION, "%Ga, %gc", }, [OP_NOT_P_v6p] = {"!", "not.p", - ev_pointer, ev_invalid, ev_integer, + ev_pointer, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_IF_v6p] = {"", "if", - ev_integer, ev_short, ev_invalid, + ev_int, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", }, [OP_IFNOT_v6p] = {"", "ifnot", - ev_integer, ev_short, ev_invalid, + ev_int, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", }, [OP_IFBE_v6p] = {"", "ifbe", - ev_integer, ev_short, ev_invalid, + ev_int, ev_short, ev_invalid, PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, [OP_IFB_v6p] = {"", "ifb", - ev_integer, ev_short, ev_invalid, + ev_int, ev_short, ev_invalid, PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, [OP_IFAE_v6p] = {"", "ifae", - ev_integer, ev_short, ev_invalid, + ev_int, ev_short, ev_invalid, PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, [OP_IFA_v6p] = {"", "ifa", - ev_integer, ev_short, ev_invalid, + ev_int, ev_short, ev_invalid, PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, @@ -944,22 +944,22 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "branch %sa (%Oa)", }, [OP_JUMP_v6p] = {"", "jump", - ev_integer, ev_invalid, ev_invalid, + ev_int, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, [OP_JUMPB_v6p] = {"", "jumpb", - ev_void, ev_integer, ev_invalid, + ev_void, ev_int, ev_invalid, PROG_V6P_VERSION, "%Ga[%Gb]", }, [OP_AND_v6p] = {"&&", "and.f", - ev_float, ev_float, ev_integer, + ev_float, ev_float, ev_int, PROG_ID_VERSION, }, [OP_OR_v6p] = {"||", "or.f", - ev_float, ev_float, ev_integer, + ev_float, ev_float, ev_int, PROG_ID_VERSION, }, @@ -972,15 +972,15 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { PROG_V6P_VERSION, }, [OP_SHL_I_v6p] = {"<<", "shl.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_SHR_I_v6p] = {">>", "shr.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_SHR_U_v6p] = {">>", "shr.u", - ev_uinteger, ev_integer, ev_uinteger, + ev_uint, ev_int, ev_uint, PROG_V6P_VERSION, }, @@ -994,35 +994,35 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_ADD_I_v6p] = {"+", "add.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_SUB_I_v6p] = {"-", "sub.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_MUL_I_v6p] = {"*", "mul.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_DIV_I_v6p] = {"/", "div.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_REM_I_v6p] = {"%", "rem.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_MOD_I_v6p] = {"%%", "mod.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_BITAND_I_v6p] = {"&", "bitand.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_BITOR_I_v6p] = {"|", "bitor.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, @@ -1037,58 +1037,58 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_GE_I_v6p] = {">=", "ge.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_LE_I_v6p] = {"<=", "le.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_GT_I_v6p] = {">", "gt.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_LT_I_v6p] = {"<", "lt.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_AND_I_v6p] = {"&&", "and.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_OR_I_v6p] = {"||", "or.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_NOT_I_v6p] = {"!", "not.i", - ev_integer, ev_invalid, ev_integer, + ev_int, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_EQ_I_v6p] = {"==", "eq.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_NE_I_v6p] = {"!=", "ne.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_GE_U_v6p] = {">=", "ge.u", - ev_uinteger, ev_uinteger, ev_integer, + ev_uint, ev_uint, ev_int, PROG_V6P_VERSION, }, [OP_LE_U_v6p] = {"<=", "le.u", - ev_uinteger, ev_uinteger, ev_integer, + ev_uint, ev_uint, ev_int, PROG_V6P_VERSION, }, [OP_GT_U_v6p] = {">", "gt.u", - ev_uinteger, ev_uinteger, ev_integer, + ev_uint, ev_uint, ev_int, PROG_V6P_VERSION, }, [OP_LT_U_v6p] = {"<", "lt.u", - ev_uinteger, ev_uinteger, ev_integer, + ev_uint, ev_uint, ev_int, PROG_V6P_VERSION, }, @@ -1102,37 +1102,37 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, %gc", }, [OP_BITXOR_I_v6p] = {"^", "bitxor.i", - ev_integer, ev_integer, ev_integer, + ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, [OP_BITNOT_I_v6p] = {"~", "bitnot.i", - ev_integer, ev_invalid, ev_integer, + ev_int, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_GE_P_v6p] = {">=", "ge.p", - ev_pointer, ev_pointer, ev_integer, + ev_pointer, ev_pointer, ev_int, PROG_V6P_VERSION, }, [OP_LE_P_v6p] = {"<=", "le.p", - ev_pointer, ev_pointer, ev_integer, + ev_pointer, ev_pointer, ev_int, PROG_V6P_VERSION, }, [OP_GT_P_v6p] = {">", "gt.p", - ev_pointer, ev_pointer, ev_integer, + ev_pointer, ev_pointer, ev_int, PROG_V6P_VERSION, }, [OP_LT_P_v6p] = {"<", "lt.p", - ev_pointer, ev_pointer, ev_integer, + ev_pointer, ev_pointer, ev_int, PROG_V6P_VERSION, }, [OP_EQ_P_v6p] = {"==", "eq.p", - ev_pointer, ev_pointer, ev_integer, + ev_pointer, ev_pointer, ev_int, PROG_V6P_VERSION, }, [OP_NE_P_v6p] = {"!=", "ne.p", - ev_pointer, ev_pointer, ev_integer, + ev_pointer, ev_pointer, ev_int, PROG_V6P_VERSION, }, @@ -1142,7 +1142,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, %sb, %gc", }, [OP_MOVEP_v6p] = {"", "movep", - ev_pointer, ev_integer, ev_pointer, + ev_pointer, ev_int, ev_pointer, PROG_V6P_VERSION, "%Ga, %Gb, %Gc", }, @@ -1152,17 +1152,17 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, %sb, %Gc", }, [OP_MEMSETI_v6p] = {"", "memseti", - ev_integer, ev_short, ev_void, + ev_int, ev_short, ev_void, PROG_V6P_VERSION, "%Ga, %sb, %gc", }, [OP_MEMSETP_v6p] = {"", "memsetp", - ev_integer, ev_integer, ev_pointer, + ev_int, ev_int, ev_pointer, PROG_V6P_VERSION, "%Ga, %Gb, %Gc", }, [OP_MEMSETPI_v6p] = {"", "memsetpi", - ev_integer, ev_short, ev_pointer, + ev_int, ev_short, ev_pointer, PROG_V6P_VERSION, "%Ga, %sb, %Gc", }, @@ -1208,7 +1208,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga", }, [OP_PUSH_I_v6p] = {"", "push.i", - ev_integer, ev_invalid, ev_invalid, + ev_int, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, @@ -1219,52 +1219,52 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_PUSHB_S_v6p] = {"", "pushb.s", - ev_pointer, ev_integer, ev_string, + ev_pointer, ev_int, ev_string, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_F_v6p] = {"", "pushb.f", - ev_pointer, ev_integer, ev_float, + ev_pointer, ev_int, ev_float, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_V_v6p] = {"", "pushb.v", - ev_pointer, ev_integer, ev_vector, + ev_pointer, ev_int, ev_vector, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_ENT_v6p] = {"", "pushb.ent", - ev_pointer, ev_integer, ev_entity, + ev_pointer, ev_int, ev_entity, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_FLD_v6p] = {"", "pushb.fld", - ev_pointer, ev_integer, ev_field, + ev_pointer, ev_int, ev_field, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_FN_v6p] = {"", "pushb.fn", - ev_pointer, ev_integer, ev_func, + ev_pointer, ev_int, ev_func, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_P_v6p] = {"", "pushb.p", - ev_pointer, ev_integer, ev_pointer, + ev_pointer, ev_int, ev_pointer, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_Q_v6p] = {"", "pushb.q", - ev_pointer, ev_integer, ev_quat, + ev_pointer, ev_int, ev_quat, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_I_v6p] = {"", "pushb.i", - ev_pointer, ev_integer, ev_integer, + ev_pointer, ev_int, ev_int, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_D_v6p] = {"", "pushb.d", - ev_pointer, ev_integer, ev_double, + ev_pointer, ev_int, ev_double, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, @@ -1310,7 +1310,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "*(%Ga + %sb)", }, [OP_PUSHBI_I_v6p] = {"", "pushbi.i", - ev_pointer, ev_short, ev_integer, + ev_pointer, ev_short, ev_int, PROG_V6P_VERSION, "*(%Ga + %sb)", }, @@ -1361,7 +1361,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%ga", }, [OP_POP_I_v6p] = {"", "pop.i", - ev_integer, ev_invalid, ev_invalid, + ev_int, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%ga", }, @@ -1372,52 +1372,52 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_POPB_S_v6p] = {"", "popb.s", - ev_pointer, ev_integer, ev_string, + ev_pointer, ev_int, ev_string, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_F_v6p] = {"", "popb.f", - ev_pointer, ev_integer, ev_float, + ev_pointer, ev_int, ev_float, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_V_v6p] = {"", "popb.v", - ev_pointer, ev_integer, ev_vector, + ev_pointer, ev_int, ev_vector, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_ENT_v6p] = {"", "popb.ent", - ev_pointer, ev_integer, ev_entity, + ev_pointer, ev_int, ev_entity, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_FLD_v6p] = {"", "popb.fld", - ev_pointer, ev_integer, ev_field, + ev_pointer, ev_int, ev_field, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_FN_v6p] = {"", "popb.fn", - ev_pointer, ev_integer, ev_func, + ev_pointer, ev_int, ev_func, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_P_v6p] = {"", "popb.p", - ev_pointer, ev_integer, ev_pointer, + ev_pointer, ev_int, ev_pointer, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_Q_v6p] = {"", "popb.q", - ev_pointer, ev_integer, ev_quat, + ev_pointer, ev_int, ev_quat, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_I_v6p] = {"", "popb.i", - ev_pointer, ev_integer, ev_integer, + ev_pointer, ev_int, ev_int, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_D_v6p] = {"", "popb.d", - ev_pointer, ev_integer, ev_double, + ev_pointer, ev_int, ev_double, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, @@ -1463,7 +1463,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "*(%Ga + %sb)", }, [OP_POPBI_I_v6p] = {"", "popbi.i", - ev_pointer, ev_short, ev_integer, + ev_pointer, ev_short, ev_int, PROG_V6P_VERSION, "*(%Ga + %sb)", }, @@ -1652,7 +1652,7 @@ PR_Check_Opcodes (progs_t *pr) break; case OP_DONE_v6p: case OP_RETURN_v6p: - check_global (pr, st, op, ev_integer, st->a, 1); + check_global (pr, st, op, ev_int, st->a, 1); check_global (pr, st, op, ev_void, st->b, 0); check_global (pr, st, op, ev_void, st->c, 0); break; @@ -1666,8 +1666,8 @@ PR_Check_Opcodes (progs_t *pr) case OP_RCALL7_v6p: case OP_RCALL8_v6p: if (st_op > OP_RCALL1_v6p) - check_global (pr, st, op, ev_integer, st->c, 1); - check_global (pr, st, op, ev_integer, st->b, 1); + check_global (pr, st, op, ev_int, st->c, 1); + check_global (pr, st, op, ev_int, st->b, 1); check_global (pr, st, op, ev_func, st->a, 1); break; case OP_STATE_v6p: diff --git a/libs/gib/bi_gib.c b/libs/gib/bi_gib.c index 2b1c6c5b4..726e18d8b 100644 --- a/libs/gib/bi_gib.c +++ b/libs/gib/bi_gib.c @@ -86,7 +86,7 @@ bi_gib_builtin_f (void) pr_list = PR_Zone_Malloc (builtin->pr, GIB_Argc() * sizeof (pr_type_t)); for (i = 0; i < GIB_Argc(); i++) - pr_list[i].integer_var = PR_SetTempString (builtin->pr, GIB_Argv(i)); + pr_list[i].int_var = PR_SetTempString (builtin->pr, GIB_Argv(i)); PR_RESET_PARAMS (builtin->pr); P_INT (builtin->pr, 0) = GIB_Argc(); diff --git a/libs/ruamoko/pr_cmds.c b/libs/ruamoko/pr_cmds.c index 36827ad4e..5aed0b2a4 100644 --- a/libs/ruamoko/pr_cmds.c +++ b/libs/ruamoko/pr_cmds.c @@ -295,7 +295,7 @@ PF_Find (progs_t *pr) continue; RETURN_EDICT (pr, ed); return; - case ev_integer: + case ev_int: case ev_entity: if (P_INT (pr, 2) != E_INT (ed, f)) continue; @@ -420,7 +420,7 @@ PF_nextent (progs_t *pr) #endif /* - integer (float f) ftoi + int (float f) ftoi */ static void PF_ftoi (progs_t *pr) @@ -453,7 +453,7 @@ PF_ftos (progs_t *pr) } /* - float (integer i) itof + float (int i) itof */ static void PF_itof (progs_t *pr) @@ -462,7 +462,7 @@ PF_itof (progs_t *pr) } /* - string (integer i) itos + string (int i) itos */ static void PF_itos (progs_t *pr) @@ -484,7 +484,7 @@ PF_stof (progs_t *pr) } /* - integer (string s) stoi + int (string s) stoi */ static void PF_stoi (progs_t *pr) diff --git a/libs/ruamoko/rua_hash.c b/libs/ruamoko/rua_hash.c index 4c8b86049..27a40d3d5 100644 --- a/libs/ruamoko/rua_hash.c +++ b/libs/ruamoko/rua_hash.c @@ -259,7 +259,7 @@ bi_Hash_FindList (progs_t *pr) pr_list = PR_Zone_Malloc (pr, count * sizeof (pr_type_t)); // the hash tables stores progs pointers... for (count = 0, l = list; *l; l++) - pr_list[count++].integer_var = (intptr_t) *l; + pr_list[count++].int_var = (intptr_t) *l; free (list); RETURN_POINTER (pr, pr_list); } @@ -278,7 +278,7 @@ bi_Hash_FindElementList (progs_t *pr) pr_list = PR_Zone_Malloc (pr, count * sizeof (pr_type_t)); // the hash tables stores progs pointers... for (count = 0, l = list; *l; l++) - pr_list[count++].integer_var = (intptr_t) *l; + pr_list[count++].int_var = (intptr_t) *l; free (list); RETURN_POINTER (pr, pr_list); } @@ -334,7 +334,7 @@ bi_Hash_GetList (progs_t *pr) pr_list = PR_Zone_Malloc (pr, count * sizeof (pr_type_t)); // the hash tables stores progs pointers... for (count = 0, l = list; *l; l++) - pr_list[count++].integer_var = (intptr_t) *l; + pr_list[count++].int_var = (intptr_t) *l; free (list); RETURN_POINTER (pr, pr_list); } diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index fafc4fe85..66994f65c 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -1444,21 +1444,21 @@ static void rua_obj_increment_retaincount (progs_t *pr) { pr_type_t *obj = &P_STRUCT (pr, pr_type_t, 0); - R_INT (pr) = ++(*--obj).integer_var; + R_INT (pr) = ++(*--obj).int_var; } static void rua_obj_decrement_retaincount (progs_t *pr) { pr_type_t *obj = &P_STRUCT (pr, pr_type_t, 0); - R_INT (pr) = --(*--obj).integer_var; + R_INT (pr) = --(*--obj).int_var; } static void rua_obj_get_retaincount (progs_t *pr) { pr_type_t *obj = &P_STRUCT (pr, pr_type_t, 0); - R_INT (pr) = (*--obj).integer_var; + R_INT (pr) = (*--obj).int_var; } static void diff --git a/libs/video/renderer/vulkan/vkgen/vktype.r b/libs/video/renderer/vulkan/vkgen/vktype.r index f9776dcd4..aa32f3a41 100644 --- a/libs/video/renderer/vulkan/vkgen/vktype.r +++ b/libs/video/renderer/vulkan/vkgen/vktype.r @@ -77,7 +77,7 @@ static string get_type_key (void *type, void *unused) -(string) name { if (type.meta == ty_basic) { - if (type.type == ev_integer) { + if (type.type == ev_int) { return "int"; } return pr_type_name[type.type]; @@ -123,7 +123,7 @@ static string get_type_key (void *type, void *unused) -(string) parseData { if (type.meta == ty_basic) { - if (type.type == ev_integer) { + if (type.type == ev_int) { return "&cexpr_int"; } return "&cexpr_" + pr_type_name[type.type]; diff --git a/nq/include/sv_progs.h b/nq/include/sv_progs.h index 975515eb0..a660b4e77 100644 --- a/nq/include/sv_progs.h +++ b/nq/include/sv_progs.h @@ -187,7 +187,7 @@ extern progs_t sv_pr_state; #define SVfunc(e,f) SVFIELD (e, f, func) #define SVentity(e,f) SVFIELD (e, f, entity) #define SVvector(e,f) (&SVFIELD (e, f, vector)) -#define SVinteger(e,f) SVFIELD (e, f, integer) +#define SVint(e,f) SVFIELD (e, f, int) #if TYPECHECK_PROGS #define SVdouble(e,f) E_DOUBLE (e, PR_AccessField (&sv_pr_state, #f, ev_##t, __FILE__, __LINE__)) #else diff --git a/nq/source/sv_progs.c b/nq/source/sv_progs.c index 3a8c44dd2..5c94f8080 100644 --- a/nq/source/sv_progs.c +++ b/nq/source/sv_progs.c @@ -323,7 +323,7 @@ static sv_def_t nq_opt_funcs[] = { }; static sv_def_t nq_opt_fields[] = { - {ev_integer, 0, "rotated_bbox", &sv_fields.rotated_bbox}, + {ev_int, 0, "rotated_bbox", &sv_fields.rotated_bbox}, {ev_float, 0, "alpha", &sv_fields.alpha}, {ev_float, 0, "gravity", &sv_fields.gravity}, {ev_float, 0, "items2", &sv_fields.items2}, @@ -355,8 +355,8 @@ set_address (sv_def_t *def, void *address) case ev_field: case ev_func: case ev_pointer: - case ev_integer: - case ev_uinteger: + case ev_int: + case ev_uint: *(pr_int_t **)def->field = (pr_int_t *) address; break; case ev_long: diff --git a/nq/source/world.c b/nq/source/world.c index a73e7c498..b8b423d83 100644 --- a/nq/source/world.c +++ b/nq/source/world.c @@ -215,7 +215,7 @@ SV_HullForEntity (edict_t *ent, const vec3_t mins, const vec3_t maxs, vec3_t hullmins, hullmaxs, size; if ((sv_fields.rotated_bbox != -1 - && SVinteger (ent, rotated_bbox)) + && SVint (ent, rotated_bbox)) || SVfloat (ent, solid) == SOLID_BSP) { VectorSubtract (maxs, mins, size); if (size[0] < 3) @@ -226,8 +226,8 @@ SV_HullForEntity (edict_t *ent, const vec3_t mins, const vec3_t maxs, hull_index = 2; } if (sv_fields.rotated_bbox != -1 - && SVinteger (ent, rotated_bbox)) { - int h = SVinteger (ent, rotated_bbox) - 1; + && SVint (ent, rotated_bbox)) { + int h = SVint (ent, rotated_bbox) - 1; hull_list = pf_hull_list[h]->hulls; } if (SVfloat (ent, solid) == SOLID_BSP) { // explicit hulls in the BSP model diff --git a/qw/include/sv_progs.h b/qw/include/sv_progs.h index c3391e2fb..b4d931c35 100644 --- a/qw/include/sv_progs.h +++ b/qw/include/sv_progs.h @@ -194,7 +194,7 @@ extern progs_t sv_pr_state; #define SVfunc(e,f) SVFIELD (e, f, func) #define SVentity(e,f) SVFIELD (e, f, entity) #define SVvector(e,f) (&SVFIELD (e, f, vector)) -#define SVinteger(e,f) SVFIELD (e, f, integer) +#define SVint(e,f) SVFIELD (e, f, int) #if TYPECHECK_PROGS #define SVdouble(e,f) E_DOUBLE (e, PR_AccessField (&sv_pr_state, #f, ev_##t, __FILE__, __LINE__)) #else diff --git a/qw/source/sv_progs.c b/qw/source/sv_progs.c index 87b871ec9..8937e7fc8 100644 --- a/qw/source/sv_progs.c +++ b/qw/source/sv_progs.c @@ -352,7 +352,7 @@ static sv_def_t qw_opt_funcs[] = { }; static sv_def_t qw_opt_fields[] = { - {ev_integer, 0, "rotated_bbox", &sv_fields.rotated_bbox}, + {ev_int, 0, "rotated_bbox", &sv_fields.rotated_bbox}, {ev_float, 0, "alpha", &sv_fields.alpha}, {ev_float, 0, "scale", &sv_fields.scale}, {ev_float, 0, "glow_size", &sv_fields.glow_size}, @@ -388,8 +388,8 @@ set_address (sv_def_t *def, void *address) case ev_field: case ev_func: case ev_pointer: - case ev_integer: - case ev_uinteger: + case ev_int: + case ev_uint: *(pr_int_t **)def->field = (pr_int_t *) address; break; case ev_long: diff --git a/qw/source/sv_user.c b/qw/source/sv_user.c index 490127b33..2f37404b6 100644 --- a/qw/source/sv_user.c +++ b/qw/source/sv_user.c @@ -1548,8 +1548,8 @@ AddLinksToPmove (areanode_t *node) pe->info = NUM_FOR_EDICT (&sv_pr_state, check); if (sv_fields.rotated_bbox != -1 - && SVinteger (check, rotated_bbox)) { - int h = SVinteger (check, rotated_bbox) - 1; + && SVint (check, rotated_bbox)) { + int h = SVint (check, rotated_bbox) - 1; pe->hull = pf_hull_list[h]->hulls[1]; } else { diff --git a/qw/source/world.c b/qw/source/world.c index 877db0f38..7024bca6c 100644 --- a/qw/source/world.c +++ b/qw/source/world.c @@ -215,7 +215,7 @@ SV_HullForEntity (edict_t *ent, const vec3_t mins, const vec3_t maxs, vec3_t hullmins, hullmaxs, size; if ((sv_fields.rotated_bbox != -1 - && SVinteger (ent, rotated_bbox)) + && SVint (ent, rotated_bbox)) || SVfloat (ent, solid) == SOLID_BSP) { VectorSubtract (maxs, mins, size); if (size[0] < 3) @@ -226,8 +226,8 @@ SV_HullForEntity (edict_t *ent, const vec3_t mins, const vec3_t maxs, hull_index = 2; } if (sv_fields.rotated_bbox != -1 - && SVinteger (ent, rotated_bbox)) { - int h = SVinteger (ent, rotated_bbox) - 1; + && SVint (ent, rotated_bbox)) { + int h = SVint (ent, rotated_bbox) - 1; hull_list = pf_hull_list[h]->hulls; } if (SVfloat (ent, solid) == SOLID_BSP) { // explicit hulls in the BSP model diff --git a/ruamoko/cl_menu/plistmenu.r b/ruamoko/cl_menu/plistmenu.r index f94e6bdfc..2694e48b5 100644 --- a/ruamoko/cl_menu/plistmenu.r +++ b/ruamoko/cl_menu/plistmenu.r @@ -84,7 +84,7 @@ class_from_plist (PLDictionary *pldict) if (str_str (paramstr, ".") >= 0) va_list.list[j].float_val = stof (paramstr); else - va_list.list[j].integer_val = stoi (paramstr); + va_list.list[j].int_val = stoi (paramstr); break; } } diff --git a/ruamoko/include/types.h b/ruamoko/include/types.h index 19ec0c736..7054eeead 100644 --- a/ruamoko/include/types.h +++ b/ruamoko/include/types.h @@ -11,8 +11,8 @@ typedef enum { ev_func, ev_pointer, // end of v6 types ev_quat, - ev_integer, - ev_uinteger, + ev_int, + ev_uint, ev_short, // value is embedded in the opcode ev_double, diff --git a/ruamoko/qwaq/debugger/typeencodings.r b/ruamoko/qwaq/debugger/typeencodings.r index d6246e2ef..64429b273 100644 --- a/ruamoko/qwaq/debugger/typeencodings.r +++ b/ruamoko/qwaq/debugger/typeencodings.r @@ -221,7 +221,7 @@ error: break; case ty_enum: // enums are ints - size = pr_type_size[ev_integer]; + size = pr_type_size[ev_int]; break; case ty_class: //FIXME diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 61ff0b7ca..f75fd79ba 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -201,8 +201,8 @@ typedef struct ex_value_s { ex_func_t func_val; ///< function constant ex_pointer_t pointer; ///< pointer constant float quaternion_val[4]; ///< quaternion constant - int integer_val; ///< integer constant - unsigned uinteger_val; ///< unsigned integer constant + int int_val; ///< int constant + unsigned uint_val; ///< unsigned int constant short short_val; ///< short constant } v; } ex_value_t; @@ -571,23 +571,23 @@ expr_t *new_pointer_expr (int val, struct type_s *type, struct def_s *def); expr_t *new_quaternion_expr (const float *quaternion_val); const float *expr_quaternion (expr_t *e) __attribute__((pure)); -/** Create a new integer constant expression node. +/** Create a new itn constant expression node. - \param integer_val The integer constant being represented. - \return The new integer constant expression node - (expr_t::e::integer_val). + \param int_val The int constant being represented. + \return The new int constant expression node + (expr_t::e::int_val). */ -expr_t *new_integer_expr (int integer_val); -int expr_integer (expr_t *e) __attribute__((pure)); +expr_t *new_int_expr (int int_val); +int expr_int (expr_t *e) __attribute__((pure)); -/** Create a new integer constant expression node. +/** Create a new int constant expression node. - \param uinteger_val The integer constant being represented. - \return The new integer constant expression node - (expr_t::e::integer_val). + \param uint_val The int constant being represented. + \return The new int constant expression node + (expr_t::e::int_val). */ -expr_t *new_uinteger_expr (unsigned uinteger_val); -unsigned expr_uinteger (expr_t *e) __attribute__((pure)); +expr_t *new_uint_expr (unsigned uint_val); +unsigned expr_uint (expr_t *e) __attribute__((pure)); /** Create a new short constant expression node. @@ -652,8 +652,8 @@ int is_string_val (expr_t *e) __attribute__((pure)); int is_float_val (expr_t *e) __attribute__((pure)); int is_vector_val (expr_t *e) __attribute__((pure)); int is_quaternion_val (expr_t *e) __attribute__((pure)); -int is_integer_val (expr_t *e) __attribute__((pure)); -int is_uinteger_val (expr_t *e) __attribute__((pure)); +int is_int_val (expr_t *e) __attribute__((pure)); +int is_uint_val (expr_t *e) __attribute__((pure)); int is_short_val (expr_t *e) __attribute__((pure)); int is_integral_val (expr_t *e) __attribute__((pure)); int is_pointer_val (expr_t *e) __attribute__((pure)); diff --git a/tools/qfcc/include/obj_file.h b/tools/qfcc/include/obj_file.h index 2aec16095..aecd3801a 100644 --- a/tools/qfcc/include/obj_file.h +++ b/tools/qfcc/include/obj_file.h @@ -334,10 +334,10 @@ enum { */ #define QFO_FLOAT(q, s, o) QFO_var (q, s, float, o) -/** Access a integer variable in the object file. Can be assigned to. +/** Access a int variable in the object file. Can be assigned to. \par QC type: - \c integer + \c int \param q pointer to ::qfo_t struct \param s space index \param o offset into object file data space @@ -345,7 +345,7 @@ enum { \hideinitializer */ -#define QFO_INT(q, s, o) QFO_var (q, s, integer, o) +#define QFO_INT(q, s, o) QFO_var (q, s, int, o) /** Access a vector variable in the object file. Can be assigned to. @@ -438,7 +438,7 @@ enum { \hideinitializer */ -#define QFO_POINTER(q, s, t, o) ((t *)(char *)&QFO_var (q, s, integer, o)) +#define QFO_POINTER(q, s, t, o) ((t *)(char *)&QFO_var (q, s, int, o)) /** Access a structure variable in the object file. Can be assigned to. diff --git a/tools/qfcc/include/qfcc.h b/tools/qfcc/include/qfcc.h index c129e8271..b678cc5a4 100644 --- a/tools/qfcc/include/qfcc.h +++ b/tools/qfcc/include/qfcc.h @@ -100,7 +100,7 @@ extern pr_info_t pr; #define D_var(t, d) ((d)->space->data[(d)->offset].t##_var) #define D_DOUBLE(d) (*(double *) ((d)->space->data + (d)->offset)) #define D_FLOAT(d) D_var (float, d) -#define D_INT(d) D_var (integer, d) +#define D_INT(d) D_var (int, d) #define D_VECTOR(d) (&D_var (vector, d)) #define D_QUAT(d) (&D_var (quat, d)) #define D_STRING(d) D_var (string, d) diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h index f985ea826..87ca80966 100644 --- a/tools/qfcc/include/type.h +++ b/tools/qfcc/include/type.h @@ -108,8 +108,8 @@ extern type_t type_function; extern type_t type_pointer; extern type_t type_floatfield; extern type_t type_quaternion; -extern type_t type_integer; -extern type_t type_uinteger; +extern type_t type_int; +extern type_t type_uint; extern type_t type_short; extern type_t *type_nil; // for passing nil into ... @@ -161,8 +161,8 @@ void encode_type (struct dstring_s *encoding, const type_t *type); const char *type_get_encoding (const type_t *type); int is_void (const type_t *type) __attribute__((pure)); int is_enum (const type_t *type) __attribute__((pure)); -int is_integer (const type_t *type) __attribute__((pure)); -int is_uinteger (const type_t *type) __attribute__((pure)); +int is_int (const type_t *type) __attribute__((pure)); +int is_uint (const type_t *type) __attribute__((pure)); int is_short (const type_t *type) __attribute__((pure)); int is_integral (const type_t *type) __attribute__((pure)); int is_double (const type_t *type) __attribute__((pure)); diff --git a/tools/qfcc/include/value.h b/tools/qfcc/include/value.h index a2f13dd67..21e10f43d 100644 --- a/tools/qfcc/include/value.h +++ b/tools/qfcc/include/value.h @@ -53,8 +53,8 @@ struct ex_value_s *new_pointer_val (int val, struct type_s *type, struct def_s *def, struct operand_s *tempop); struct ex_value_s *new_quaternion_val (const float *quaternion_val); -struct ex_value_s *new_integer_val (int integer_val); -struct ex_value_s *new_uinteger_val (int uinteger_val); +struct ex_value_s *new_int_val (int int_val); +struct ex_value_s *new_uint_val (int uint_val); struct ex_value_s *new_short_val (short short_val); struct ex_value_s *new_nil_val (struct type_s *type); diff --git a/tools/qfcc/source/class.c b/tools/qfcc/source/class.c index 99d6fbcb2..de0d473e6 100644 --- a/tools/qfcc/source/class.c +++ b/tools/qfcc/source/class.c @@ -132,7 +132,7 @@ static struct_def_t category_struct[] = { static struct_def_t ivar_struct[] = { {"ivar_name", &type_string}, {"ivar_type", &type_string}, - {"ivar_offset", &type_integer}, + {"ivar_offset", &type_int}, {0, 0} }; @@ -143,8 +143,8 @@ static struct_def_t super_struct[] = { }; static struct_def_t module_struct[] = { - {"version", &type_integer}, - {"size", &type_integer}, + {"version", &type_int}, + {"size", &type_int}, {"name", &type_string}, {"symtab", &type_pointer}, {0, 0} @@ -154,9 +154,9 @@ static struct_def_t class_struct[] = { {"class_pointer", &type_Class}, {"super_class", &type_Class}, {"name", &type_string}, - {"version", &type_integer}, - {"info", &type_integer}, - {"instance_size", &type_integer}, + {"version", &type_int}, + {"info", &type_int}, + {"instance_size", &type_int}, {"ivars", &type_pointer}, {"methods", &type_pointer}, {"dtable", &type_pointer}, @@ -729,8 +729,8 @@ emit_ivar_count (def_t *def, void *data, int index) { ivar_data_t *ivar_data = (ivar_data_t *) data; - if (!is_integer(def->type)) - internal_error (0, "%s: expected integer def", __FUNCTION__); + if (!is_int(def->type)) + internal_error (0, "%s: expected int def", __FUNCTION__); D_INT (def) = ivar_data->count; } @@ -774,8 +774,8 @@ static def_t * emit_ivars (symtab_t *ivars, const char *name) { static struct_def_t ivar_list_struct[] = { - {"ivar_count", &type_integer, emit_ivar_count}, - {"ivar_list", 0, emit_ivar_list_item}, + {"ivar_count", &type_int, emit_ivar_count}, + {"ivar_list", 0, emit_ivar_list_item}, {0, 0} }; ivar_data_t ivar_data = {0, 0, 0}; @@ -1411,8 +1411,8 @@ emit_symtab_ref_cnt (def_t *def, void *data, int index) { obj_symtab_data_t *da = (obj_symtab_data_t *)data; - if (!is_integer(def->type)) - internal_error (0, "%s: expected integer def", __FUNCTION__); + if (!is_int(def->type)) + internal_error (0, "%s: expected int def", __FUNCTION__); D_INT (def) = 0; if (da->refs) D_INT (def) = da->refs->type->t.array.size; @@ -1435,8 +1435,8 @@ emit_symtab_cls_def_cnt (def_t *def, void *data, int index) { obj_symtab_data_t *da = (obj_symtab_data_t *)data; - if (!is_integer(def->type)) - internal_error (0, "%s: expected integer def", __FUNCTION__); + if (!is_int(def->type)) + internal_error (0, "%s: expected int def", __FUNCTION__); D_INT (def) = da->cls_def_cnt; } @@ -1445,8 +1445,8 @@ emit_symtab_cat_def_cnt (def_t *def, void *data, int index) { obj_symtab_data_t *da = (obj_symtab_data_t *)data; - if (!is_integer(def->type)) - internal_error (0, "%s: expected integer def", __FUNCTION__); + if (!is_int(def->type)) + internal_error (0, "%s: expected int def", __FUNCTION__); D_INT (def) = da->cat_def_cnt; } @@ -1489,11 +1489,11 @@ void class_finish_module (void) { static struct_def_t symtab_struct[] = { - {"sel_ref_cnt", &type_integer, emit_symtab_ref_cnt}, - {"refs", &type_SEL, emit_symtab_refs}, - {"cls_def_cnt", &type_integer, emit_symtab_cls_def_cnt}, - {"cat_def_cnt", &type_integer, emit_symtab_cat_def_cnt}, - {"defs", 0, emit_symtab_defs}, + {"sel_ref_cnt", &type_int, emit_symtab_ref_cnt}, + {"refs", &type_SEL, emit_symtab_refs}, + {"cls_def_cnt", &type_int, emit_symtab_cls_def_cnt}, + {"cat_def_cnt", &type_int, emit_symtab_cat_def_cnt}, + {"defs", 0, emit_symtab_defs}, {0, 0} }; @@ -1750,8 +1750,8 @@ emit_protocol_count (def_t *def, void *data, int index) { protocollist_t *protocols = (protocollist_t *) data; - if (!is_integer(def->type)) { - internal_error (0, "%s: expected integer def", __FUNCTION__); + if (!is_int(def->type)) { + internal_error (0, "%s: expected int def", __FUNCTION__); } D_INT (def) = protocols->count; } @@ -1777,7 +1777,7 @@ emit_protocol_list (protocollist_t *protocols, const char *name) { static struct_def_t proto_list_struct[] = { {"next", &type_pointer, emit_protocol_next}, - {"count", &type_integer, emit_protocol_count}, + {"count", &type_int, emit_protocol_count}, {"list", 0, emit_protocol_list_item}, {0, 0}, }; diff --git a/tools/qfcc/source/constfold.c b/tools/qfcc/source/constfold.c index 6ee98f70e..20a9c5716 100644 --- a/tools/qfcc/source/constfold.c +++ b/tools/qfcc/source/constfold.c @@ -76,7 +76,7 @@ cmp_result_expr (int result) if (is_float (type_default)) { return new_float_expr (result); } else { - return new_integer_expr(result); + return new_int_expr(result); } } @@ -92,7 +92,7 @@ do_op_string (int op, expr_t *e, expr_t *e1, expr_t *e2) if (is_compare (op) || is_logic (op)) { if (options.code.progsversion > PROG_ID_VERSION) - e->e.expr.type = &type_integer; + e->e.expr.type = &type_int; else e->e.expr.type = &type_float; } else { @@ -153,7 +153,7 @@ convert_to_float (expr_t *e) switch (e->type) { case ex_value: switch (e->e.value->lltype) { - case ev_integer: + case ev_int: convert_int (e); return e; case ev_short: @@ -188,8 +188,8 @@ convert_to_double (expr_t *e) switch (e->type) { case ex_value: switch (e->e.value->lltype) { - case ev_integer: - e->e.value = new_double_val (expr_integer (e)); + case ev_int: + e->e.value = new_double_val (expr_int (e)); return e; case ev_short: e->e.value = new_double_val (expr_short (e)); @@ -235,7 +235,7 @@ do_op_float (int op, expr_t *e, expr_t *e1, expr_t *e2) } if (is_compare (op) || is_logic (op)) { if (options.code.progsversion > PROG_ID_VERSION) - type = &type_integer; + type = &type_int; else type = &type_float; } @@ -354,7 +354,7 @@ do_op_double (int op, expr_t *e, expr_t *e1, expr_t *e2) e->e.expr.e2 = e2 = conv; } if (is_compare (op) || is_logic (op)) { - type = &type_integer; + type = &type_int; } e->e.expr.type = type; @@ -456,7 +456,7 @@ do_op_vector (int op, expr_t *e, expr_t *e1, expr_t *e2) } if (is_compare (op) || is_logic (op)) { if (options.code.progsversion > PROG_ID_VERSION) - e->e.expr.type = &type_integer; + e->e.expr.type = &type_int; else e->e.expr.type = &type_float; } else if (op == '*' && is_vector(get_type (e2))) { @@ -555,7 +555,7 @@ do_op_entity (int op, expr_t *e, expr_t *e1, expr_t *e2) } if (op == EQ || op == NE) { if (options.code.progsversion > PROG_ID_VERSION) - e->e.expr.type = &type_integer; + e->e.expr.type = &type_int; else e->e.expr.type = &type_float; return e; @@ -577,7 +577,7 @@ do_op_func (int op, expr_t *e, expr_t *e1, expr_t *e2) { if (op == EQ || op == NE) { if (options.code.progsversion > PROG_ID_VERSION) - e->e.expr.type = &type_integer; + e->e.expr.type = &type_int; else e->e.expr.type = &type_float; return e; @@ -606,23 +606,23 @@ do_op_pointer (int op, expr_t *e, expr_t *e1, expr_t *e2) type = get_type (e1); if (type != get_type (e2)) return error (e2, "invalid operands to binary -"); - e1 = new_alias_expr (&type_integer, e1); - e2 = new_alias_expr (&type_integer, e2); + e1 = new_alias_expr (&type_int, e1); + e2 = new_alias_expr (&type_int, e2); e = binary_expr ('-', e1, e2); if (type_size (type) != 1) - e = binary_expr ('/', e, new_integer_expr (type_size (type))); + e = binary_expr ('/', e, new_int_expr (type_size (type))); return e; } if (op == EQ || op == NE) { if (options.code.progsversion > PROG_ID_VERSION) - e->e.expr.type = &type_integer; + e->e.expr.type = &type_int; else e->e.expr.type = &type_float; } if (op != '.' && extract_type (e1) != extract_type (e2)) return type_mismatch (e1, e2, op); - if (op == '.' && is_uinteger(get_type (e2))) - e->e.expr.e2 = cf_cast_expr (&type_integer, e2); + if (op == '.' && is_uint(get_type (e2))) + e->e.expr.e2 = cf_cast_expr (&type_int, e2); return e; } @@ -677,7 +677,7 @@ do_op_quaternion (int op, expr_t *e, expr_t *e1, expr_t *e2) } if (is_compare (op) || is_logic (op)) { if (options.code.progsversion > PROG_ID_VERSION) - e->e.expr.type = &type_integer; + e->e.expr.type = &type_int; else e->e.expr.type = &type_float; } else if (op == '/' && !is_constant (e1)) { @@ -759,7 +759,7 @@ do_op_quaternion (int op, expr_t *e, expr_t *e1, expr_t *e2) } static expr_t * -do_op_integer (int op, expr_t *e, expr_t *e1, expr_t *e2) +do_op_int (int op, expr_t *e, expr_t *e1, expr_t *e2) { int isval1 = 0, isval2 = 0; int val1 = 0, val2 = 0; @@ -769,33 +769,33 @@ do_op_integer (int op, expr_t *e, expr_t *e1, expr_t *e2) }; if (!valid_op (op, valid)) - return error (e1, "invalid operator for integer"); + return error (e1, "invalid operator for int"); if (is_short_val (e1)) { isval1 = 1; val1 = expr_short (e1); } - if (is_integer_val (e1)) { + if (is_int_val (e1)) { isval1 = 1; - val1 = expr_integer (e1); + val1 = expr_int (e1); } if (is_short_val (e2)) { isval2 = 1; val2 = expr_short (e2); } - if (is_integer_val (e2)) { + if (is_int_val (e2)) { isval2 = 1; - val2 = expr_integer (e2); + val2 = expr_int (e2); } if (is_compare (op) || is_logic (op)) { if (options.code.progsversion > PROG_ID_VERSION) - e->e.expr.type = &type_integer; + e->e.expr.type = &type_int; else e->e.expr.type = &type_float; } else { - e->e.expr.type = &type_integer; + e->e.expr.type = &type_int; } if (op == '*' && isval1 && val1 == 1) @@ -824,36 +824,36 @@ do_op_integer (int op, expr_t *e, expr_t *e1, expr_t *e2) switch (op) { case '+': - e = new_integer_expr (val1 + val2); + e = new_int_expr (val1 + val2); break; case '-': - e = new_integer_expr (val1 - val2); + e = new_int_expr (val1 - val2); break; case '*': - e = new_integer_expr (val1 * val2); + e = new_int_expr (val1 * val2); break; case '/': if (options.warnings.integer_divide) warning (e2, "%d / %d == %d", val1, val2, val1 / val2); - e = new_integer_expr (val1 / val2); + e = new_int_expr (val1 / val2); break; case '&': - e = new_integer_expr (val1 & val2); + e = new_int_expr (val1 & val2); break; case '|': - e = new_integer_expr (val1 | val2); + e = new_int_expr (val1 | val2); break; case '^': - e = new_integer_expr (val1 ^ val2); + e = new_int_expr (val1 ^ val2); break; case '%': - e = new_integer_expr (val1 % val2); + e = new_int_expr (val1 % val2); break; case SHL: - e = new_integer_expr (val1 << val2); + e = new_int_expr (val1 << val2); break; case SHR: - e = new_integer_expr (val1 >> val2); + e = new_int_expr (val1 >> val2); break; case AND: e = cmp_result_expr (val1 && val2); @@ -888,7 +888,7 @@ do_op_integer (int op, expr_t *e, expr_t *e1, expr_t *e2) } static expr_t * -do_op_uinteger (int op, expr_t *e, expr_t *e1, expr_t *e2) +do_op_uint (int op, expr_t *e, expr_t *e1, expr_t *e2) { return e; } @@ -907,7 +907,7 @@ do_op_short (int op, expr_t *e, expr_t *e1, expr_t *e2) if (is_compare (op) || is_logic (op)) { if (options.code.progsversion > PROG_ID_VERSION) - e->e.expr.type = &type_integer; + e->e.expr.type = &type_int; else e->e.expr.type = &type_float; } else { @@ -1004,14 +1004,14 @@ do_op_compound (int op, expr_t *e, expr_t *e1, expr_t *e2) return do_op_float (op, e, e1, e2); if (t2->type == ev_double) return do_op_float (op, e, e1, e2); - return do_op_integer (op, e, e1, e2); + return do_op_int (op, e, e1, e2); } if (is_enum (t2)) { if (t1->type == ev_double) return do_op_double (op, e, e1, e2); if (t1->type == ev_float) return do_op_float (op, e, e1, e2); - return do_op_integer (op, e, e1, e2); + return do_op_int (op, e, e1, e2); } } return error (e1, "invalid operator for compound"); @@ -1062,8 +1062,8 @@ static operation_t op_void[ev_type_count] = { do_op_invalid, // ev_func do_op_invalid, // ev_pointer do_op_invalid, // ev_quaternion - do_op_invalid, // ev_integer - do_op_invalid, // ev_uinteger + do_op_invalid, // ev_int + do_op_invalid, // ev_uint do_op_invalid, // ev_short do_op_invalid, // ev_double 0, // ev_long @@ -1081,8 +1081,8 @@ static operation_t op_string[ev_type_count] = { do_op_invalid, // ev_func do_op_invalid, // ev_pointer do_op_invalid, // ev_quaternion - do_op_invalid, // ev_integer - do_op_invalid, // ev_uinteger + do_op_invalid, // ev_int + do_op_invalid, // ev_uint do_op_invalid, // ev_short do_op_invalid, // ev_double 0, // ev_long @@ -1100,8 +1100,8 @@ static operation_t op_float[ev_type_count] = { do_op_invalid, // ev_func do_op_invalid, // ev_pointer do_op_quaternion, // ev_quaternion - do_op_float, // ev_integer - do_op_float, // ev_uinteger + do_op_float, // ev_int + do_op_float, // ev_uint do_op_float, // ev_short do_op_double, // ev_double 0, // ev_long @@ -1119,8 +1119,8 @@ static operation_t op_vector[ev_type_count] = { do_op_invalid, // ev_func do_op_invalid, // ev_pointer do_op_invalid, // ev_quaternion - do_op_vector, // ev_integer - do_op_vector, // ev_uinteger + do_op_vector, // ev_int + do_op_vector, // ev_uint do_op_vector, // ev_short do_op_vector, // ev_double 0, // ev_long @@ -1138,8 +1138,8 @@ static operation_t op_entity[ev_type_count] = { do_op_invalid, // ev_func do_op_invalid, // ev_pointer do_op_invalid, // ev_quaternion - do_op_invalid, // ev_integer - do_op_invalid, // ev_uinteger + do_op_invalid, // ev_int + do_op_invalid, // ev_uint do_op_invalid, // ev_short do_op_invalid, // ev_double 0, // ev_long @@ -1157,8 +1157,8 @@ static operation_t op_field[ev_type_count] = { do_op_invalid, // ev_func do_op_invalid, // ev_pointer do_op_invalid, // ev_quaternion - do_op_invalid, // ev_integer - do_op_invalid, // ev_uinteger + do_op_invalid, // ev_int + do_op_invalid, // ev_uint do_op_invalid, // ev_short do_op_invalid, // ev_double 0, // ev_long @@ -1176,8 +1176,8 @@ static operation_t op_func[ev_type_count] = { do_op_func, // ev_func do_op_func, // ev_pointer do_op_func, // ev_quaternion - do_op_func, // ev_integer - do_op_func, // ev_uinteger + do_op_func, // ev_int + do_op_func, // ev_uint do_op_func, // ev_short do_op_func, // ev_double 0, // ev_long @@ -1195,8 +1195,8 @@ static operation_t op_pointer[ev_type_count] = { do_op_pointer, // ev_func do_op_pointer, // ev_pointer do_op_pointer, // ev_quaternion - do_op_pointer, // ev_integer - do_op_pointer, // ev_uinteger + do_op_pointer, // ev_int + do_op_pointer, // ev_uint do_op_pointer, // ev_short do_op_pointer, // ev_double 0, // ev_long @@ -1214,8 +1214,8 @@ static operation_t op_quaternion[ev_type_count] = { do_op_invalid, // ev_func do_op_invalid, // ev_pointer do_op_quaternion, // ev_quaternion - do_op_quaternion, // ev_integer - do_op_quaternion, // ev_uinteger + do_op_quaternion, // ev_int + do_op_quaternion, // ev_uint do_op_quaternion, // ev_short do_op_quaternion, // ev_double 0, // ev_long @@ -1223,7 +1223,7 @@ static operation_t op_quaternion[ev_type_count] = { do_op_invalid, // ev_invalid }; -static operation_t op_integer[ev_type_count] = { +static operation_t op_int[ev_type_count] = { do_op_invalid, // ev_void do_op_invalid, // ev_string do_op_float, // ev_float @@ -1233,16 +1233,16 @@ static operation_t op_integer[ev_type_count] = { do_op_invalid, // ev_func do_op_invalid, // ev_pointer do_op_quaternion, // ev_quaternion - do_op_integer, // ev_integer - do_op_uinteger, // ev_uinteger - do_op_integer, // ev_short + do_op_int, // ev_int + do_op_uint, // ev_uint + do_op_int, // ev_short do_op_double, // ev_double 0, // ev_long 0, // ev_ulong do_op_invalid, // ev_invalid }; -static operation_t op_uinteger[ev_type_count] = { +static operation_t op_uint[ev_type_count] = { do_op_invalid, // ev_void do_op_invalid, // ev_string do_op_float, // ev_float @@ -1252,9 +1252,9 @@ static operation_t op_uinteger[ev_type_count] = { do_op_invalid, // ev_func do_op_invalid, // ev_pointer do_op_quaternion, // ev_quaternion - do_op_uinteger, // ev_integer - do_op_uinteger, // ev_uinteger - do_op_uinteger, // ev_short + do_op_uint, // ev_int + do_op_uint, // ev_uint + do_op_uint, // ev_short do_op_double, // ev_double 0, // ev_long 0, // ev_ulong @@ -1271,8 +1271,8 @@ static operation_t op_short[ev_type_count] = { do_op_invalid, // ev_func do_op_invalid, // ev_pointer do_op_quaternion, // ev_quaternion - do_op_integer, // ev_integer - do_op_uinteger, // ev_uinteger + do_op_int, // ev_int + do_op_uint, // ev_uint do_op_short, // ev_short do_op_double, // ev_double 0, // ev_long @@ -1290,8 +1290,8 @@ static operation_t op_double[ev_type_count] = { do_op_invalid, // ev_func do_op_invalid, // ev_pointer do_op_quaternion, // ev_quaternion - do_op_integer, // ev_integer - do_op_uinteger, // ev_uinteger + do_op_int, // ev_int + do_op_uint, // ev_uint do_op_short, // ev_short do_op_double, // ev_double 0, // ev_long @@ -1309,8 +1309,8 @@ static operation_t op_compound[ev_type_count] = { do_op_invalid, // ev_func do_op_invalid, // ev_pointer do_op_invalid, // ev_quaternion - do_op_compound, // ev_integer - do_op_compound, // ev_uinteger + do_op_compound, // ev_int + do_op_compound, // ev_uint do_op_compound, // ev_short do_op_compound, // ev_double do_op_compound, // ev_long @@ -1328,8 +1328,8 @@ static operation_t *do_op[ev_type_count] = { op_func, // ev_func op_pointer, // ev_pointer op_quaternion, // ev_quaternion - op_integer, // ev_integer - op_uinteger, // ev_uinteger + op_int, // ev_int + op_uint, // ev_uint op_short, // ev_short op_double, // ev_double 0, // ev_long @@ -1390,7 +1390,7 @@ uop_float (int op, expr_t *e, expr_t *e1) if (op == '+') return e1; type = get_type (e); - if (op == 'C' && !is_integer(type) && !is_double(type)) + if (op == 'C' && !is_int(type) && !is_double(type)) return error (e1, "invalid cast of float"); if (!is_constant (e1)) return e; @@ -1403,8 +1403,8 @@ uop_float (int op, expr_t *e, expr_t *e1) case '~': return new_float_expr (~(int) expr_float (e1)); case 'C': - if (is_integer(type)) { - return new_integer_expr (expr_float (e1)); + if (is_int(type)) { + return new_int_expr (expr_float (e1)); } else { return new_double_expr (expr_float (e1)); } @@ -1533,7 +1533,7 @@ uop_quaternion (int op, expr_t *e, expr_t *e1) } static expr_t * -uop_integer (int op, expr_t *e, expr_t *e1) +uop_int (int op, expr_t *e, expr_t *e1) { static int valid[] = { '+', '-', '!', '~', 'C', 0 }; @@ -1548,19 +1548,19 @@ uop_integer (int op, expr_t *e, expr_t *e1) return e; switch (op) { case '-': - return new_integer_expr (-expr_integer (e1)); + return new_int_expr (-expr_int (e1)); case '!': - return cmp_result_expr (!expr_integer (e1)); + return cmp_result_expr (!expr_int (e1)); case '~': - return new_integer_expr (~expr_integer (e1)); + return new_int_expr (~expr_int (e1)); case 'C': - return new_float_expr (expr_integer (e1)); + return new_float_expr (expr_int (e1)); } - internal_error (e, "integer unary op blew up"); + internal_error (e, "int unary op blew up"); } static expr_t * -uop_uinteger (int op, expr_t *e, expr_t *e1) +uop_uint (int op, expr_t *e, expr_t *e1) { static int valid[] = { '+', '-', '!', '~', 0 }; @@ -1573,13 +1573,13 @@ uop_uinteger (int op, expr_t *e, expr_t *e1) return e; switch (op) { case '-': - return new_uinteger_expr (-expr_uinteger (e1)); + return new_uint_expr (-expr_uint (e1)); case '!': - return cmp_result_expr (!expr_uinteger (e1)); + return cmp_result_expr (!expr_uint (e1)); case '~': - return new_uinteger_expr (~expr_uinteger (e1)); + return new_uint_expr (~expr_uint (e1)); } - internal_error (e, "uinteger unary op blew up"); + internal_error (e, "uint unary op blew up"); } static expr_t * @@ -1617,7 +1617,7 @@ uop_double (int op, expr_t *e, expr_t *e1) if (op == '+') return e1; type = get_type (e); - if (op == 'C' && !is_integer(type) && !is_float(type)) + if (op == 'C' && !is_int(type) && !is_float(type)) return error (e1, "invalid cast of double"); if (!is_constant (e1)) return e; @@ -1628,8 +1628,8 @@ uop_double (int op, expr_t *e, expr_t *e1) print_type (get_type (e)); return cmp_result_expr (!expr_double (e1)); case 'C': - if (is_integer(type)) { - return new_integer_expr (expr_double (e1)); + if (is_int(type)) { + return new_int_expr (expr_double (e1)); } else { return new_float_expr (expr_double (e1)); } @@ -1644,7 +1644,7 @@ uop_compound (int op, expr_t *e, expr_t *e1) if (is_scalar (t1)) { if (is_enum (t1)) { - return uop_integer (op, e, e1); + return uop_int (op, e, e1); } } return error (e1, "invalid operand for unary %s", get_op_string (op)); @@ -1660,8 +1660,8 @@ static unaryop_t do_unary_op[ev_type_count] = { uop_func, // ev_func uop_pointer, // ev_pointer uop_quaternion, // ev_quaternion - uop_integer, // ev_integer - uop_uinteger, // ev_uinteger + uop_int, // ev_int + uop_uint, // ev_uint uop_short, // ev_short uop_double, // ev_double uop_compound, // ev_invalid diff --git a/tools/qfcc/source/debug.c b/tools/qfcc/source/debug.c index 644ee31d9..4afff69ee 100644 --- a/tools/qfcc/source/debug.c +++ b/tools/qfcc/source/debug.c @@ -164,7 +164,7 @@ emit_basedir (def_t *def, void *data, int index) static void emit_num_files (def_t *def, void *data, int index) { - if (!is_integer (def->type)) { + if (!is_int (def->type)) { internal_error (0, "%s: expected int def", __FUNCTION__); } D_INT (def) = pr.comp_files.size; @@ -189,7 +189,7 @@ emit_compunit (const char *modname) static struct_def_t compunit_struct[] = { {"unit_name", &type_string, emit_unit_name}, {"basedir", &type_string, emit_basedir}, - {"num_files", &type_integer, emit_num_files}, + {"num_files", &type_int, emit_num_files}, {"files", 0, emit_files_item}, {0, 0} }; diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c index 94cc49ce1..cf854a1b4 100644 --- a/tools/qfcc/source/def.c +++ b/tools/qfcc/source/def.c @@ -378,8 +378,7 @@ init_elements (struct def_s *def, expr_t *eles) reloc_def_op (c->e.labelref.label, &dummy); continue; } else if (c->type == ex_value) { - if (c->e.value->lltype == ev_integer - && is_float (element->type)) { + if (c->e.value->lltype == ev_int && is_float (element->type)) { convert_int (c); } if (is_double (get_type (c)) && is_float (element->type) @@ -610,7 +609,7 @@ initialize_def (symbol_t *sym, expr_t *init, defspace_t *space, } while (init->type == ex_alias) { if (init->e.alias.offset) { - offset += expr_integer (init->e.alias.offset); + offset += expr_int (init->e.alias.offset); } init = init->e.alias.expr; } diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index a66009bd5..d1cbfee26 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -573,16 +573,16 @@ print_value (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) } break; case ev_entity: - label = va (0, "ent %d", e->e.value->v.integer_val); + label = va (0, "ent %d", e->e.value->v.int_val); break; case ev_func: - label = va (0, "func %d", e->e.value->v.integer_val); + label = va (0, "func %d", e->e.value->v.int_val); break; - case ev_integer: - label = va (0, "i %d", e->e.value->v.integer_val); + case ev_int: + label = va (0, "i %d", e->e.value->v.int_val); break; - case ev_uinteger: - label = va (0, "u %u", e->e.value->v.uinteger_val); + case ev_uint: + label = va (0, "u %u", e->e.value->v.uint_val); break; case ev_long: label = va (0, "i %"PRIi64, e->e.value->v.long_val); diff --git a/tools/qfcc/source/dot_type.c b/tools/qfcc/source/dot_type.c index 522fa91fb..fa77bbf3d 100644 --- a/tools/qfcc/source/dot_type.c +++ b/tools/qfcc/source/dot_type.c @@ -169,7 +169,7 @@ print_struct (dstring_t *dstr, type_t *t, int level, int id) int val; const char *port = ""; if (sym->sy_type == sy_const) { - val = sym->s.value->v.integer_val; + val = sym->s.value->v.int_val; } else { if (sym->sy_type != sy_var) { continue; diff --git a/tools/qfcc/source/dump_globals.c b/tools/qfcc/source/dump_globals.c index f27f33d4b..e55c10104 100644 --- a/tools/qfcc/source/dump_globals.c +++ b/tools/qfcc/source/dump_globals.c @@ -141,7 +141,7 @@ dump_def (progs_t *pr, pr_def_t *def, int indent) G_QUAT (pr, offset)[2], G_QUAT (pr, offset)[3]); break; - case ev_integer: + case ev_int: comment = va (0, " %d", G_INT (pr, offset)); break; case ev_short: @@ -327,7 +327,7 @@ qfo_globals (qfo_t *qfo) QFO_TYPESTR (qfo, def->type)); if (!(def->flags & QFOD_EXTERNAL) && qfo->spaces[space].data) printf (" %d", - qfo->spaces[space].data[def->offset].integer_var); + qfo->spaces[space].data[def->offset].int_var); puts (""); } } diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 0b70c6ae4..47daa1348 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -91,7 +91,7 @@ convert_name (expr_t *e) } if (!strcmp (sym->name, "__LINE__") && current_func) { - new = new_integer_expr (e->line); + new = new_int_expr (e->line); goto convert; } if (!strcmp (sym->name, "__INFINITY__") @@ -230,7 +230,7 @@ get_type (expr_t *e) case ex_bool: if (options.code.progsversion == PROG_ID_VERSION) return &type_float; - return &type_integer; + return &type_int; case ex_nil: if (e->e.nil) { return e->e.nil; @@ -888,20 +888,20 @@ new_quaternion_expr (const float *quaternion_val) } expr_t * -new_integer_expr (int integer_val) +new_int_expr (int int_val) { expr_t *e = new_expr (); e->type = ex_value; - e->e.value = new_integer_val (integer_val); + e->e.value = new_int_val (int_val); return e; } expr_t * -new_uinteger_expr (unsigned uinteger_val) +new_uint_expr (unsigned uint_val) { expr_t *e = new_expr (); e->type = ex_value; - e->e.value = new_uinteger_val (uinteger_val); + e->e.value = new_uint_val (uint_val); return e; } @@ -1104,12 +1104,12 @@ expr_quaternion (expr_t *e) } int -is_integer_val (expr_t *e) +is_int_val (expr_t *e) { if (e->type == ex_nil) { return 1; } - if (e->type == ex_value && e->e.value->lltype == ev_integer) { + if (e->type == ex_value && e->e.value->lltype == ev_int) { return 1; } if (e->type == ex_symbol && e->e.symbol->sy_type == sy_const @@ -1124,18 +1124,18 @@ is_integer_val (expr_t *e) } int -expr_integer (expr_t *e) +expr_int (expr_t *e) { if (e->type == ex_nil) { return 0; } - if (e->type == ex_value && e->e.value->lltype == ev_integer) { - return e->e.value->v.integer_val; + if (e->type == ex_value && e->e.value->lltype == ev_int) { + return e->e.value->v.int_val; } if (e->type == ex_symbol && e->e.symbol->sy_type == sy_const - && (e->e.symbol->type->type == ev_integer + && (e->e.symbol->type->type == ev_int || is_enum (e->e.symbol->type))) { - return e->e.symbol->s.value->v.integer_val; + return e->e.symbol->s.value->v.int_val; } if (e->type == ex_symbol && e->e.symbol->sy_type == sy_var && e->e.symbol->s.def->constant @@ -1146,16 +1146,16 @@ expr_integer (expr_t *e) && is_integral (e->e.def->type)) { return D_INT (e->e.def); } - internal_error (e, "not an integer constant"); + internal_error (e, "not an int constant"); } int -is_uinteger_val (expr_t *e) +is_uint_val (expr_t *e) { if (e->type == ex_nil) { return 1; } - if (e->type == ex_value && e->e.value->lltype == ev_uinteger) { + if (e->type == ex_value && e->e.value->lltype == ev_uint) { return 1; } if (e->type == ex_symbol && e->e.symbol->sy_type == sy_const @@ -1170,17 +1170,17 @@ is_uinteger_val (expr_t *e) } unsigned -expr_uinteger (expr_t *e) +expr_uint (expr_t *e) { if (e->type == ex_nil) { return 0; } - if (e->type == ex_value && e->e.value->lltype == ev_uinteger) { - return e->e.value->v.uinteger_val; + if (e->type == ex_value && e->e.value->lltype == ev_uint) { + return e->e.value->v.uint_val; } if (e->type == ex_symbol && e->e.symbol->sy_type == sy_const - && e->e.symbol->type->type == ev_uinteger) { - return e->e.symbol->s.value->v.uinteger_val; + && e->e.symbol->type->type == ev_uint) { + return e->e.symbol->s.value->v.uint_val; } if (e->type == ex_symbol && e->e.symbol->sy_type == sy_var && e->e.symbol->s.def->constant @@ -1230,10 +1230,10 @@ int is_integral_val (expr_t *e) { if (is_constant (e)) { - if (is_integer_val (e)) { + if (is_int_val (e)) { return 1; } - if (is_uinteger_val (e)) { + if (is_uint_val (e)) { return 1; } if (is_short_val (e)) { @@ -1247,11 +1247,11 @@ int expr_integral (expr_t *e) { if (is_constant (e)) { - if (is_integer_val (e)) { - return expr_integer (e); + if (is_int_val (e)) { + return expr_int (e); } - if (is_uinteger_val (e)) { - return expr_uinteger (e); + if (is_uint_val (e)) { + return expr_uint (e); } if (is_short_val (e)) { return expr_short (e); @@ -1293,7 +1293,7 @@ new_offset_alias_expr (type_t *type, expr_t *expr, int offset) if (!is_constant (ofs_expr)) { internal_error (ofs_expr, "non-constant offset for alias expr"); } - offset += expr_integer (ofs_expr); + offset += expr_int (ofs_expr); if (expr->e.alias.expr->type == ex_alias) { internal_error (expr, "alias expr of alias expr"); @@ -1305,7 +1305,7 @@ new_offset_alias_expr (type_t *type, expr_t *expr, int offset) alias->type = ex_alias; alias->e.alias.type = type; alias->e.alias.expr = expr; - alias->e.alias.offset = new_integer_expr (offset); + alias->e.alias.offset = new_int_expr (offset); alias->file = expr->file; alias->line = expr->line; return alias; @@ -1517,14 +1517,14 @@ convert_from_bool (expr_t *e, type_t *type) if (is_float (type)) { one = new_float_expr (1); zero = new_float_expr (0); - } else if (is_integer (type)) { - one = new_integer_expr (1); - zero = new_integer_expr (0); + } else if (is_int (type)) { + one = new_int_expr (1); + zero = new_int_expr (0); } else if (is_enum (type) && enum_as_bool (type, &zero, &one)) { // don't need to do anything - } else if (is_uinteger (type)) { - one = new_uinteger_expr (1); - zero = new_uinteger_expr (0); + } else if (is_uint (type)) { + one = new_uint_expr (1); + zero = new_uint_expr (0); } else { return error (e, "can't convert from bool value"); } @@ -1541,7 +1541,7 @@ convert_from_bool (expr_t *e, type_t *type) void convert_int (expr_t *e) { - float float_val = expr_integer (e); + float float_val = expr_int (e); e->type = ex_value; e->e.value = new_float_val (float_val); } @@ -1557,9 +1557,9 @@ convert_short (expr_t *e) void convert_short_int (expr_t *e) { - float integer_val = expr_short (e); + float int_val = expr_short (e); e->type = ex_value; - e->e.value = new_integer_val (integer_val); + e->e.value = new_int_val (int_val); } void @@ -1712,10 +1712,10 @@ unary_expr (int op, expr_t *e) case ev_long: case ev_ulong: internal_error (e, "long not implemented"); - case ev_integer: - return new_integer_expr (-expr_integer (e)); - case ev_uinteger: - return new_uinteger_expr (-expr_uinteger (e)); + case ev_int: + return new_int_expr (-expr_int (e)); + case ev_uint: + return new_uint_expr (-expr_uint (e)); case ev_short: return new_short_expr (-expr_short (e)); case ev_invalid: @@ -1801,22 +1801,22 @@ unary_expr (int op, expr_t *e) internal_error (e, 0); case ev_string: s = expr_string (e); - return new_integer_expr (!s || !s[0]); + return new_int_expr (!s || !s[0]); case ev_double: - return new_integer_expr (!expr_double (e)); + return new_int_expr (!expr_double (e)); case ev_float: - return new_integer_expr (!expr_float (e)); + return new_int_expr (!expr_float (e)); case ev_vector: - return new_integer_expr (!VectorIsZero (expr_vector (e))); + return new_int_expr (!VectorIsZero (expr_vector (e))); case ev_quat: - return new_integer_expr (!QuatIsZero (expr_quaternion (e))); + return new_int_expr (!QuatIsZero (expr_quaternion (e))); case ev_long: case ev_ulong: internal_error (e, "long not implemented"); - case ev_integer: - return new_integer_expr (!expr_integer (e)); - case ev_uinteger: - return new_uinteger_expr (!expr_uinteger (e)); + case ev_int: + return new_int_expr (!expr_int (e)); + case ev_uint: + return new_uint_expr (!expr_uint (e)); case ev_short: return new_short_expr (!expr_short (e)); case ev_invalid: @@ -1856,7 +1856,7 @@ unary_expr (int op, expr_t *e) expr_t *n = new_unary_expr (op, e); if (options.code.progsversion > PROG_ID_VERSION) - n->e.expr.type = &type_integer; + n->e.expr.type = &type_int; else n->e.expr.type = &type_float; return n; @@ -1887,16 +1887,16 @@ unary_expr (int op, expr_t *e) case ev_long: case ev_ulong: internal_error (e, "long not implemented"); - case ev_integer: - return new_integer_expr (~expr_integer (e)); - case ev_uinteger: - return new_uinteger_expr (~expr_uinteger (e)); + case ev_int: + return new_int_expr (~expr_int (e)); + case ev_uint: + return new_uint_expr (~expr_uint (e)); case ev_short: return new_short_expr (~expr_short (e)); case ev_invalid: t = get_type (e); if (t->meta == ty_enum) { - return new_integer_expr (~expr_integer (e)); + return new_int_expr (~expr_int (e)); } break; case ev_type_count: @@ -1936,13 +1936,13 @@ unary_expr (int op, expr_t *e) case ex_assign: bitnot_expr: if (options.code.progsversion == PROG_ID_VERSION) { - expr_t *n1 = new_integer_expr (-1); + expr_t *n1 = new_int_expr (-1); return binary_expr ('-', n1, e); } else { expr_t *n = new_unary_expr (op, e); type_t *t = get_type (e); - if (!is_integer(t) && !is_float(t) + if (!is_int(t) && !is_float(t) && !is_quaternion(t)) return error (e, "invalid type for unary ~"); n->e.expr.type = t; @@ -2052,7 +2052,7 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) convert_nil (e, t = type_nil); if (e->type == ex_bool) convert_from_bool (e, get_type (e)); - if (is_integer_val (e) + if (is_int_val (e) && options.code.progsversion == PROG_ID_VERSION) convert_int (e); if (options.code.promote_float) { @@ -2070,8 +2070,8 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) } } } - if (is_integer_val (e) && options.warnings.vararg_integer) - warning (e, "passing integer constant into ... function"); + if (is_int_val (e) && options.warnings.vararg_integer) + warning (e, "passing int constant into ... function"); } arg_types[arg_count - 1 - i] = t; } @@ -2265,7 +2265,7 @@ return_expr (function_t *f, expr_t *e) if (e->type == ex_bool) { e = convert_from_bool (e, (type_t *) ret_type); //FIXME cast } - if (is_float(ret_type) && is_integer_val (e)) { + if (is_float(ret_type) && is_int_val (e)) { convert_int (e); t = &type_float; } @@ -2352,7 +2352,7 @@ incop_expr (int op, expr_t *e, int postop) if (e->type == ex_error) return e; - one = new_integer_expr (1); // integer constants get auto-cast to float + one = new_int_expr (1); // int constants get auto-cast to float if (postop) { expr_t *t1, *t2; type_t *type = get_type (e); @@ -2398,22 +2398,22 @@ array_expr (expr_t *array, expr_t *index) return error (index, "invalid array index type"); if (is_short_val (index)) ind = expr_short (index); - if (is_integer_val (index)) - ind = expr_integer (index); + if (is_int_val (index)) + ind = expr_int (index); if (array_type->t.func.num_params && is_constant (index) && (ind < array_type->t.array.base || ind - array_type->t.array.base >= array_type->t.array.size)) return error (index, "array index out of bounds"); - scale = new_integer_expr (type_size (array_type->t.array.type)); + scale = new_int_expr (type_size (array_type->t.array.type)); index = binary_expr ('*', index, scale); - base = new_integer_expr (array_type->t.array.base); + base = new_int_expr (array_type->t.array.base); offset = binary_expr ('*', base, scale); index = binary_expr ('-', index, offset); if (is_short_val (index)) ind = expr_short (index); - if (is_integer_val (index)) - ind = expr_integer (index); + if (is_int_val (index)) + ind = expr_int (index); if ((is_constant (index) && ind < 32768 && ind >= -32768)) index = new_short_expr (ind); if (is_array (array_type)) { @@ -2438,7 +2438,7 @@ pointer_expr (expr_t *pointer) return pointer; if (pointer_type->type != ev_pointer) return error (pointer, "not a pointer"); - return array_expr (pointer, new_integer_expr (0)); + return array_expr (pointer, new_int_expr (0)); } expr_t * @@ -2754,7 +2754,7 @@ build_state_expr (expr_t *e) step = think->next; if (think->type == ex_symbol) think = think_expr (think->e.symbol); - if (is_integer_val (frame)) + if (is_int_val (frame)) convert_int (frame); if (!type_assignable (&type_float, get_type (frame))) return error (frame, "invalid type for frame number"); @@ -2763,7 +2763,7 @@ build_state_expr (expr_t *e) if (step) { if (step->next) return error (step->next, "too many state arguments"); - if (is_integer_val (step)) + if (is_int_val (step)) convert_int (step); if (!type_assignable (&type_float, get_type (step))) return error (step, "invalid type for step"); @@ -2843,7 +2843,7 @@ cast_expr (type_t *dstType, expr_t *e) } else if (is_double (def->type)) { val = new_double_val (D_DOUBLE (def)); } else if (is_integral (def->type)) { - val = new_integer_val (D_INT (def)); + val = new_int_val (D_INT (def)); } } else if (e->type == ex_value) { val = e->e.value; @@ -2889,7 +2889,7 @@ sizeof_expr (expr_t *expr, struct type_s *type) internal_error (0, 0); if (!type) type = get_type (expr); - expr = new_integer_expr (type_size (type)); + expr = new_int_expr (type_size (type)); return expr; } diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index df304f119..885f87ef1 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -53,12 +53,12 @@ static expr_t *double_compare (int op, expr_t *e1, expr_t *e2); static expr_type_t string_string[] = { {'+', &type_string}, - {EQ, &type_integer}, - {NE, &type_integer}, - {LE, &type_integer}, - {GE, &type_integer}, - {LT, &type_integer}, - {GT, &type_integer}, + {EQ, &type_int}, + {NE, &type_int}, + {LE, &type_int}, + {GE, &type_int}, + {LT, &type_int}, + {GT, &type_int}, {0, 0} }; @@ -74,14 +74,14 @@ static expr_type_t float_float[] = { {MOD, &type_float}, {SHL, &type_float}, {SHR, &type_float}, - {AND, &type_integer}, - {OR, &type_integer}, - {EQ, &type_integer}, - {NE, &type_integer}, - {LE, &type_integer}, - {GE, &type_integer}, - {LT, &type_integer}, - {GT, &type_integer}, + {AND, &type_int}, + {OR, &type_int}, + {EQ, &type_int}, + {NE, &type_int}, + {LE, &type_int}, + {GE, &type_int}, + {LT, &type_int}, + {GT, &type_int}, {0, 0} }; @@ -95,7 +95,7 @@ static expr_type_t float_quat[] = { {0, 0} }; -static expr_type_t float_integer[] = { +static expr_type_t float_int[] = { {'+', &type_float, 0, &type_float}, {'-', &type_float, 0, &type_float}, {'*', &type_float, 0, &type_float}, @@ -107,16 +107,16 @@ static expr_type_t float_integer[] = { {MOD, &type_float, 0, &type_float}, {SHL, &type_float, 0, &type_float}, {SHR, &type_float, 0, &type_float}, - {EQ, &type_integer, 0, &type_float}, - {NE, &type_integer, 0, &type_float}, - {LE, &type_integer, 0, &type_float}, - {GE, &type_integer, 0, &type_float}, - {LT, &type_integer, 0, &type_float}, - {GT, &type_integer, 0, &type_float}, + {EQ, &type_int, 0, &type_float}, + {NE, &type_int, 0, &type_float}, + {LE, &type_int, 0, &type_float}, + {GE, &type_int, 0, &type_float}, + {LT, &type_int, 0, &type_float}, + {GT, &type_int, 0, &type_float}, {0, 0} }; -#define float_uinteger float_integer -#define float_short float_integer +#define float_uint float_int +#define float_short float_int static expr_type_t float_double[] = { {'+', &type_double, &type_double, 0}, @@ -144,13 +144,13 @@ static expr_type_t vector_vector[] = { {'+', &type_vector}, {'-', &type_vector}, {'*', &type_float}, - {EQ, &type_integer}, - {NE, &type_integer}, + {EQ, &type_int}, + {NE, &type_int}, {0, 0} }; -#define vector_integer vector_float -#define vector_uinteger vector_float +#define vector_int vector_float +#define vector_uint vector_float #define vector_short vector_float static expr_type_t vector_double[] = { @@ -160,20 +160,20 @@ static expr_type_t vector_double[] = { }; static expr_type_t entity_entity[] = { - {EQ, &type_integer}, - {NE, &type_integer}, + {EQ, &type_int}, + {NE, &type_int}, {0, 0} }; static expr_type_t field_field[] = { - {EQ, &type_integer}, - {NE, &type_integer}, + {EQ, &type_int}, + {NE, &type_int}, {0, 0} }; static expr_type_t func_func[] = { - {EQ, &type_integer}, - {NE, &type_integer}, + {EQ, &type_int}, + {NE, &type_int}, {0, 0} }; @@ -188,13 +188,13 @@ static expr_type_t pointer_pointer[] = { {0, 0} }; -static expr_type_t pointer_integer[] = { +static expr_type_t pointer_int[] = { {'+', 0, 0, 0, pointer_arithmetic}, {'-', 0, 0, 0, pointer_arithmetic}, {0, 0} }; -#define pointer_uinteger pointer_integer -#define pointer_short pointer_integer +#define pointer_uint pointer_int +#define pointer_short pointer_int static expr_type_t quat_float[] = { {'*', &type_quaternion}, @@ -211,18 +211,18 @@ static expr_type_t quat_quat[] = { {'+', &type_quaternion}, {'-', &type_quaternion}, {'*', &type_quaternion}, - {EQ, &type_integer}, - {NE, &type_integer}, + {EQ, &type_int}, + {NE, &type_int}, {0, 0} }; -static expr_type_t quat_integer[] = { +static expr_type_t quat_int[] = { {'*', &type_quaternion, 0, &type_float}, {'/', 0, 0, 0, inverse_multiply}, {0, 0} }; -#define quat_uinteger quat_integer -#define quat_short quat_integer +#define quat_uint quat_int +#define quat_short quat_int static expr_type_t quat_double[] = { {'*', &type_quaternion}, @@ -230,7 +230,7 @@ static expr_type_t quat_double[] = { {0, 0} }; -static expr_type_t integer_float[] = { +static expr_type_t int_float[] = { {'+', &type_float, &type_float, 0}, {'-', &type_float, &type_float, 0}, {'*', &type_float, &type_float, 0}, @@ -240,206 +240,206 @@ static expr_type_t integer_float[] = { {'^', &type_float, &type_float, 0}, {'%', &type_float, &type_float, 0}, {MOD, &type_float, &type_float, 0}, - {SHL, &type_integer, 0, &type_integer}, //FIXME? - {SHR, &type_integer, 0, &type_integer}, //FIXME? - {EQ, &type_integer, &type_float, 0}, - {NE, &type_integer, &type_float, 0}, - {LE, &type_integer, &type_float, 0}, - {GE, &type_integer, &type_float, 0}, - {LT, &type_integer, &type_float, 0}, - {GT, &type_integer, &type_float, 0}, + {SHL, &type_int, 0, &type_int}, //FIXME? + {SHR, &type_int, 0, &type_int}, //FIXME? + {EQ, &type_int, &type_float, 0}, + {NE, &type_int, &type_float, 0}, + {LE, &type_int, &type_float, 0}, + {GE, &type_int, &type_float, 0}, + {LT, &type_int, &type_float, 0}, + {GT, &type_int, &type_float, 0}, {0, 0} }; -static expr_type_t integer_vector[] = { +static expr_type_t int_vector[] = { {'*', &type_vector, &type_float, 0}, {0, 0} }; -static expr_type_t integer_pointer[] = { +static expr_type_t int_pointer[] = { {'+', 0, 0, 0, pointer_arithmetic}, {0, 0} }; -static expr_type_t integer_quat[] = { +static expr_type_t int_quat[] = { {'*', &type_quaternion, &type_float, 0}, {0, 0} }; -static expr_type_t integer_integer[] = { - {'+', &type_integer}, - {'-', &type_integer}, - {'*', &type_integer}, - {'/', &type_integer}, - {'&', &type_integer}, - {'|', &type_integer}, - {'^', &type_integer}, - {'%', &type_integer}, - {MOD, &type_integer}, - {SHL, &type_integer}, - {SHR, &type_integer}, - {AND, &type_integer}, - {OR, &type_integer}, - {EQ, &type_integer}, - {NE, &type_integer}, - {LE, &type_integer}, - {GE, &type_integer}, - {LT, &type_integer}, - {GT, &type_integer}, +static expr_type_t int_int[] = { + {'+', &type_int}, + {'-', &type_int}, + {'*', &type_int}, + {'/', &type_int}, + {'&', &type_int}, + {'|', &type_int}, + {'^', &type_int}, + {'%', &type_int}, + {MOD, &type_int}, + {SHL, &type_int}, + {SHR, &type_int}, + {AND, &type_int}, + {OR, &type_int}, + {EQ, &type_int}, + {NE, &type_int}, + {LE, &type_int}, + {GE, &type_int}, + {LT, &type_int}, + {GT, &type_int}, {0, 0} }; -static expr_type_t integer_uinteger[] = { - {'+', &type_integer}, - {'-', &type_integer}, - {'*', &type_integer}, - {'/', &type_integer}, - {'&', &type_integer}, - {'|', &type_integer}, - {'^', &type_integer}, - {'%', &type_integer}, - {MOD, &type_integer}, - {SHL, &type_integer}, - {SHR, &type_integer}, - {EQ, &type_integer}, - {NE, &type_integer}, - {LE, &type_integer}, - {GE, &type_integer}, - {LT, &type_integer}, - {GT, &type_integer}, +static expr_type_t int_uint[] = { + {'+', &type_int}, + {'-', &type_int}, + {'*', &type_int}, + {'/', &type_int}, + {'&', &type_int}, + {'|', &type_int}, + {'^', &type_int}, + {'%', &type_int}, + {MOD, &type_int}, + {SHL, &type_int}, + {SHR, &type_int}, + {EQ, &type_int}, + {NE, &type_int}, + {LE, &type_int}, + {GE, &type_int}, + {LT, &type_int}, + {GT, &type_int}, {0, 0} }; -static expr_type_t integer_short[] = { - {'+', &type_integer, 0, &type_integer}, - {'-', &type_integer, 0, &type_integer}, - {'*', &type_integer, 0, &type_integer}, - {'/', &type_integer, 0, &type_integer}, - {'&', &type_integer, 0, &type_integer}, - {'|', &type_integer, 0, &type_integer}, - {'^', &type_integer, 0, &type_integer}, - {'%', &type_integer, 0, &type_integer}, - {MOD, &type_integer, 0, &type_integer}, - {SHL, &type_integer, 0, &type_integer}, - {SHR, &type_integer, 0, &type_integer}, - {EQ, &type_integer, 0, &type_integer}, - {NE, &type_integer, 0, &type_integer}, - {LE, &type_integer, 0, &type_integer}, - {GE, &type_integer, 0, &type_integer}, - {LT, &type_integer, 0, &type_integer}, - {GT, &type_integer, 0, &type_integer}, +static expr_type_t int_short[] = { + {'+', &type_int, 0, &type_int}, + {'-', &type_int, 0, &type_int}, + {'*', &type_int, 0, &type_int}, + {'/', &type_int, 0, &type_int}, + {'&', &type_int, 0, &type_int}, + {'|', &type_int, 0, &type_int}, + {'^', &type_int, 0, &type_int}, + {'%', &type_int, 0, &type_int}, + {MOD, &type_int, 0, &type_int}, + {SHL, &type_int, 0, &type_int}, + {SHR, &type_int, 0, &type_int}, + {EQ, &type_int, 0, &type_int}, + {NE, &type_int, 0, &type_int}, + {LE, &type_int, 0, &type_int}, + {GE, &type_int, 0, &type_int}, + {LT, &type_int, 0, &type_int}, + {GT, &type_int, 0, &type_int}, {0, 0} }; -static expr_type_t integer_double[] = { +static expr_type_t int_double[] = { {'+', &type_double, &type_double, 0}, {'-', &type_double, &type_double, 0}, {'*', &type_double, &type_double, 0}, {'/', &type_double, &type_double, 0}, {'%', &type_double, &type_double, 0}, {MOD, &type_double, &type_double, 0}, - {EQ, &type_integer, &type_double, 0}, - {NE, &type_integer, &type_double, 0}, - {LE, &type_integer, &type_double, 0}, - {GE, &type_integer, &type_double, 0}, - {LT, &type_integer, &type_double, 0}, - {GT, &type_integer, &type_double, 0}, + {EQ, &type_int, &type_double, 0}, + {NE, &type_int, &type_double, 0}, + {LE, &type_int, &type_double, 0}, + {GE, &type_int, &type_double, 0}, + {LT, &type_int, &type_double, 0}, + {GT, &type_int, &type_double, 0}, {0, 0} }; -#define uinteger_float integer_float -#define uinteger_vector integer_vector -#define uinteger_pointer integer_pointer -#define uinteger_quat integer_quat +#define uint_float int_float +#define uint_vector int_vector +#define uint_pointer int_pointer +#define uint_quat int_quat -static expr_type_t uinteger_integer[] = { - {'+', &type_integer}, - {'-', &type_integer}, - {'*', &type_integer}, - {'/', &type_integer}, - {'&', &type_integer}, - {'|', &type_integer}, - {'^', &type_integer}, - {'%', &type_integer}, - {MOD, &type_integer}, - {SHL, &type_uinteger}, - {SHR, &type_uinteger}, - {EQ, &type_integer}, - {NE, &type_integer}, - {LE, &type_integer}, - {GE, &type_integer}, - {LT, &type_integer}, - {GT, &type_integer}, +static expr_type_t uint_int[] = { + {'+', &type_int}, + {'-', &type_int}, + {'*', &type_int}, + {'/', &type_int}, + {'&', &type_int}, + {'|', &type_int}, + {'^', &type_int}, + {'%', &type_int}, + {MOD, &type_int}, + {SHL, &type_uint}, + {SHR, &type_uint}, + {EQ, &type_int}, + {NE, &type_int}, + {LE, &type_int}, + {GE, &type_int}, + {LT, &type_int}, + {GT, &type_int}, {0, 0} }; -static expr_type_t uinteger_uinteger[] = { - {'+', &type_uinteger}, - {'-', &type_uinteger}, - {'*', &type_uinteger}, - {'/', &type_uinteger}, - {'&', &type_uinteger}, - {'|', &type_uinteger}, - {'^', &type_uinteger}, - {'%', &type_uinteger}, - {MOD, &type_uinteger}, - {SHL, &type_uinteger}, - {SHR, &type_uinteger}, - {EQ, &type_integer}, - {NE, &type_integer}, - {LE, &type_integer}, - {GE, &type_integer}, - {LT, &type_integer}, - {GT, &type_integer}, +static expr_type_t uint_uint[] = { + {'+', &type_uint}, + {'-', &type_uint}, + {'*', &type_uint}, + {'/', &type_uint}, + {'&', &type_uint}, + {'|', &type_uint}, + {'^', &type_uint}, + {'%', &type_uint}, + {MOD, &type_uint}, + {SHL, &type_uint}, + {SHR, &type_uint}, + {EQ, &type_int}, + {NE, &type_int}, + {LE, &type_int}, + {GE, &type_int}, + {LT, &type_int}, + {GT, &type_int}, {0, 0} }; -#define uinteger_short uinteger_integer -#define uinteger_double integer_double +#define uint_short uint_int +#define uint_double int_double -#define short_float integer_float -#define short_vector integer_vector -#define short_pointer integer_pointer -#define short_quat integer_quat +#define short_float int_float +#define short_vector int_vector +#define short_pointer int_pointer +#define short_quat int_quat -static expr_type_t short_integer[] = { - {'+', &type_integer, &type_integer, 0}, - {'-', &type_integer, &type_integer, 0}, - {'*', &type_integer, &type_integer, 0}, - {'/', &type_integer, &type_integer, 0}, - {'&', &type_integer, &type_integer, 0}, - {'|', &type_integer, &type_integer, 0}, - {'^', &type_integer, &type_integer, 0}, - {'%', &type_integer, &type_integer, 0}, - {MOD, &type_integer, &type_integer, 0}, +static expr_type_t short_int[] = { + {'+', &type_int, &type_int, 0}, + {'-', &type_int, &type_int, 0}, + {'*', &type_int, &type_int, 0}, + {'/', &type_int, &type_int, 0}, + {'&', &type_int, &type_int, 0}, + {'|', &type_int, &type_int, 0}, + {'^', &type_int, &type_int, 0}, + {'%', &type_int, &type_int, 0}, + {MOD, &type_int, &type_int, 0}, {SHL, &type_short}, {SHR, &type_short}, - {EQ, &type_integer, &type_integer, 0}, - {NE, &type_integer, &type_integer, 0}, - {LE, &type_integer, &type_integer, 0}, - {GE, &type_integer, &type_integer, 0}, - {LT, &type_integer, &type_integer, 0}, - {GT, &type_integer, &type_integer, 0}, + {EQ, &type_int, &type_int, 0}, + {NE, &type_int, &type_int, 0}, + {LE, &type_int, &type_int, 0}, + {GE, &type_int, &type_int, 0}, + {LT, &type_int, &type_int, 0}, + {GT, &type_int, &type_int, 0}, {0, 0} }; -static expr_type_t short_uinteger[] = { - {'+', &type_uinteger, &type_uinteger, 0}, - {'-', &type_uinteger, &type_uinteger, 0}, - {'*', &type_uinteger, &type_uinteger, 0}, - {'/', &type_uinteger, &type_uinteger, 0}, - {'&', &type_uinteger, &type_uinteger, 0}, - {'|', &type_uinteger, &type_uinteger, 0}, - {'^', &type_uinteger, &type_uinteger, 0}, - {'%', &type_uinteger, &type_uinteger, 0}, - {MOD, &type_uinteger, &type_uinteger, 0}, +static expr_type_t short_uint[] = { + {'+', &type_uint, &type_uint, 0}, + {'-', &type_uint, &type_uint, 0}, + {'*', &type_uint, &type_uint, 0}, + {'/', &type_uint, &type_uint, 0}, + {'&', &type_uint, &type_uint, 0}, + {'|', &type_uint, &type_uint, 0}, + {'^', &type_uint, &type_uint, 0}, + {'%', &type_uint, &type_uint, 0}, + {MOD, &type_uint, &type_uint, 0}, {SHL, &type_short}, {SHR, &type_short}, - {EQ, &type_integer, &type_uinteger, 0}, - {NE, &type_integer, &type_uinteger, 0}, - {LE, &type_integer, &type_uinteger, 0}, - {GE, &type_integer, &type_uinteger, 0}, - {LT, &type_integer, &type_uinteger, 0}, - {GT, &type_integer, &type_uinteger, 0}, + {EQ, &type_int, &type_uint, 0}, + {NE, &type_int, &type_uint, 0}, + {LE, &type_int, &type_uint, 0}, + {GE, &type_int, &type_uint, 0}, + {LT, &type_int, &type_uint, 0}, + {GT, &type_int, &type_uint, 0}, {0, 0} }; @@ -455,15 +455,15 @@ static expr_type_t short_short[] = { {MOD, &type_short}, {SHL, &type_short}, {SHR, &type_short}, - {EQ, &type_integer}, - {NE, &type_integer}, - {LE, &type_integer}, - {GE, &type_integer}, - {LT, &type_integer}, - {GT, &type_integer}, + {EQ, &type_int}, + {NE, &type_int}, + {LE, &type_int}, + {GE, &type_int}, + {LT, &type_int}, + {GT, &type_int}, {0, 0} }; -#define short_double integer_double +#define short_double int_double static expr_type_t double_float[] = { {'+', &type_double, 0, &type_double}, @@ -491,7 +491,7 @@ static expr_type_t double_quat[] = { {0, 0} }; -static expr_type_t double_integer[] = { +static expr_type_t double_int[] = { {'+', &type_double, 0, &type_double}, {'-', &type_double, 0, &type_double}, {'*', &type_double, 0, &type_double}, @@ -506,8 +506,8 @@ static expr_type_t double_integer[] = { {GT, 0, 0, 0, double_compare}, {0, 0} }; -#define double_uinteger double_integer -#define double_short double_integer +#define double_uint double_int +#define double_short double_int static expr_type_t double_double[] = { {'+', &type_double}, @@ -516,12 +516,12 @@ static expr_type_t double_double[] = { {'/', &type_double}, {'%', &type_double}, {MOD, &type_double}, - {EQ, &type_integer}, - {NE, &type_integer}, - {LE, &type_integer}, - {GE, &type_integer}, - {LT, &type_integer}, - {GT, &type_integer}, + {EQ, &type_int}, + {NE, &type_int}, + {LE, &type_int}, + {GE, &type_int}, + {LT, &type_int}, + {GT, &type_int}, {0, 0} }; @@ -535,8 +535,8 @@ static expr_type_t *string_x[ev_type_count] = { 0, // ev_func 0, // ev_pointer 0, // ev_quat - 0, // ev_integer - 0, // ev_uinteger + 0, // ev_int + 0, // ev_uint 0, // ev_short 0, // ev_double }; @@ -551,8 +551,8 @@ static expr_type_t *float_x[ev_type_count] = { 0, // ev_func 0, // ev_pointer float_quat, - float_integer, - float_uinteger, + float_int, + float_uint, float_short, float_double, }; @@ -567,8 +567,8 @@ static expr_type_t *vector_x[ev_type_count] = { 0, // ev_func 0, // ev_pointer 0, // ev_quaternion - vector_integer, - vector_uinteger, + vector_int, + vector_uint, vector_short, vector_double, }; @@ -583,8 +583,8 @@ static expr_type_t *entity_x[ev_type_count] = { 0, // ev_func 0, // ev_pointer 0, // ev_quaternion - 0, // ev_integer - 0, // ev_uinteger + 0, // ev_int + 0, // ev_uint 0, // ev_short 0, // ev_double }; @@ -599,8 +599,8 @@ static expr_type_t *field_x[ev_type_count] = { 0, // ev_func 0, // ev_pointer 0, // ev_quaternion - 0, // ev_integer - 0, // ev_uinteger + 0, // ev_int + 0, // ev_uint 0, // ev_short 0, // ev_double }; @@ -615,8 +615,8 @@ static expr_type_t *func_x[ev_type_count] = { func_func, // ev_func 0, // ev_pointer 0, // ev_quaternion - 0, // ev_integer - 0, // ev_uinteger + 0, // ev_int + 0, // ev_uint 0, // ev_short 0, // ev_double }; @@ -631,8 +631,8 @@ static expr_type_t *pointer_x[ev_type_count] = { 0, // ev_func pointer_pointer, 0, // ev_quat - pointer_integer, - pointer_uinteger, + pointer_int, + pointer_uint, pointer_short, 0, // ev_double }; @@ -647,42 +647,42 @@ static expr_type_t *quat_x[ev_type_count] = { 0, // ev_func 0, // ev_pointer quat_quat, - quat_integer, - quat_uinteger, + quat_int, + quat_uint, quat_short, quat_double, }; -static expr_type_t *integer_x[ev_type_count] = { +static expr_type_t *int_x[ev_type_count] = { 0, // ev_void 0, // ev_string - integer_float, - integer_vector, + int_float, + int_vector, 0, // ev_entity 0, // ev_field 0, // ev_func - integer_pointer, - integer_quat, - integer_integer, - integer_uinteger, - integer_short, - integer_double, + int_pointer, + int_quat, + int_int, + int_uint, + int_short, + int_double, }; -static expr_type_t *uinteger_x[ev_type_count] = { +static expr_type_t *uint_x[ev_type_count] = { 0, // ev_void 0, // ev_string - uinteger_float, - uinteger_vector, + uint_float, + uint_vector, 0, // ev_entity 0, // ev_field 0, // ev_func - uinteger_pointer, - uinteger_quat, - uinteger_integer, - uinteger_uinteger, - uinteger_short, - uinteger_double, + uint_pointer, + uint_quat, + uint_int, + uint_uint, + uint_short, + uint_double, }; static expr_type_t *short_x[ev_type_count] = { @@ -695,8 +695,8 @@ static expr_type_t *short_x[ev_type_count] = { 0, // ev_func short_pointer, short_quat, - short_integer, - short_uinteger, + short_int, + short_uint, short_short, short_double, }; @@ -711,8 +711,8 @@ static expr_type_t *double_x[ev_type_count] = { 0, // ev_func 0, // ev_pointer double_quat, - double_integer, - double_uinteger, + double_int, + double_uint, double_short, double_double, }; @@ -727,8 +727,8 @@ static expr_type_t **binary_expr_types[ev_type_count] = { func_x, pointer_x, quat_x, - integer_x, - uinteger_x, + int_x, + uint_x, short_x, double_x }; @@ -755,20 +755,20 @@ pointer_arithmetic (int op, expr_t *e1, expr_t *e2) return error (e2, "cannot use %c on pointers of different types", op); } - e1 = cast_expr (&type_integer, e1); - e2 = cast_expr (&type_integer, e2); - psize = new_integer_expr (type_size (t1->t.fldptr.type)); + e1 = cast_expr (&type_int, e1); + e2 = cast_expr (&type_int, e2); + psize = new_int_expr (type_size (t1->t.fldptr.type)); return binary_expr ('/', binary_expr ('-', e1, e2), psize); } else if (is_pointer (t1)) { - offset = cast_expr (&type_integer, e2); - ptr = cast_expr (&type_integer, e1); + offset = cast_expr (&type_int, e2); + ptr = cast_expr (&type_int, e1); ptype = t1; } else if (is_pointer (t2)) { - offset = cast_expr (&type_integer, e1); - ptr = cast_expr (&type_integer, e2); + offset = cast_expr (&type_int, e1); + ptr = cast_expr (&type_int, e2); ptype = t2; } - psize = new_integer_expr (type_size (ptype->t.fldptr.type)); + psize = new_int_expr (type_size (ptype->t.fldptr.type)); e = binary_expr (op, ptr, binary_expr ('*', offset, psize)); return cast_expr (ptype, e); } @@ -785,7 +785,7 @@ pointer_compare (int op, expr_t *e1, expr_t *e2) get_op_string (op)); } e = new_binary_expr (op, e1, e2); - e->e.expr.type = &type_integer; + e->e.expr.type = &type_int; return e; } @@ -817,19 +817,19 @@ double_compare (int op, expr_t *e1, expr_t *e2) if (is_float (t2)) { warning (e2, "comparison between double and float"); } else if (!is_constant (e2)) { - warning (e2, "comparison between double and integer"); + warning (e2, "comparison between double and int"); } e2 = cast_expr (&type_double, e2); } else if (is_double (t2)) { if (is_float (t1)) { warning (e1, "comparison between float and double"); } else if (!is_constant (e1)) { - warning (e1, "comparison between integer and double"); + warning (e1, "comparison between int and double"); } e1 = cast_expr (&type_double, e1); } e = new_binary_expr (op, e1, e2); - e->e.expr.type = &type_integer; + e->e.expr.type = &type_int; return e; } diff --git a/tools/qfcc/source/expr_bool.c b/tools/qfcc/source/expr_bool.c index 9f7b0e1e4..df8e25180 100644 --- a/tools/qfcc/source/expr_bool.c +++ b/tools/qfcc/source/expr_bool.c @@ -97,10 +97,10 @@ test_expr (expr_t *e) case ev_long: case ev_ulong: internal_error (e, "long not implemented"); - case ev_uinteger: - case ev_integer: + case ev_uint: + case ev_int: case ev_short: - if (!is_integer(type_default)) { + if (!is_int(type_default)) { if (is_constant (e)) { return cast_expr (type_default, e); } @@ -285,8 +285,8 @@ convert_bool (expr_t *e, int block) int val; b = goto_expr (0); - if (is_integer_val (e)) { - val = expr_integer (e); + if (is_int_val (e)) { + val = expr_int (e); } else { val = expr_float (e) != 0; } diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index e448990b2..08a397651 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -665,7 +665,7 @@ build_builtin_function (symbol_t *sym, expr_t *bi_val, int far, error (bi_val, "%s redefined", sym->name); return 0; } - if (!is_integer_val (bi_val) && !is_float_val (bi_val)) { + if (!is_int_val (bi_val) && !is_float_val (bi_val)) { error (bi_val, "invalid constant for = #"); return 0; } @@ -681,8 +681,8 @@ build_builtin_function (symbol_t *sym, expr_t *bi_val, int far, sym->s.func->def->nosave = 1; add_function (sym->s.func); - if (is_integer_val (bi_val)) - bi = expr_integer (bi_val); + if (is_int_val (bi_val)) + bi = expr_int (bi_val); else bi = expr_float (bi_val); if (bi < 0) { diff --git a/tools/qfcc/source/method.c b/tools/qfcc/source/method.c index 9c82f89d5..67df1d3fb 100644 --- a/tools/qfcc/source/method.c +++ b/tools/qfcc/source/method.c @@ -543,8 +543,8 @@ emit_methods_count (def_t *def, void *data, int index) { methodlist_t *methods = (methodlist_t *) data; - if (!is_integer(def->type)) - internal_error (0, "%s: expected integer def", __FUNCTION__); + if (!is_int(def->type)) + internal_error (0, "%s: expected int def", __FUNCTION__); D_INT (def) = methods->count; } @@ -586,7 +586,7 @@ emit_methods (methodlist_t *methods, const char *name, int instance) { static struct_def_t methods_struct[] = { {"method_next", &type_pointer, emit_methods_next}, - {"method_count", &type_integer, emit_methods_count}, + {"method_count", &type_int, emit_methods_count}, {"method_list", 0, emit_methods_list_item}, {0, 0} }; @@ -622,8 +622,8 @@ emit_method_list_count (def_t *def, void *data, int index) { methodlist_t *methods = (methodlist_t *) data; - if (!is_integer(def->type)) - internal_error (0, "%s: expected integer def", __FUNCTION__); + if (!is_int(def->type)) + internal_error (0, "%s: expected int def", __FUNCTION__); D_INT (def) = methods->count; } @@ -660,7 +660,7 @@ emit_method_descriptions (methodlist_t *methods, const char *name, int instance) { static struct_def_t method_list_struct[] = { - {"count", &type_integer, emit_method_list_count}, + {"count", &type_int, emit_method_list_count}, {"method_list", 0, emit_method_list_item}, {0, 0} }; @@ -746,8 +746,8 @@ method_check_params (method_t *method, expr_t *args) } } } else { - if (is_integer_val (e) && options.warnings.vararg_integer) { - warning (e, "passing integer consant into ... function"); + if (is_int_val (e) && options.warnings.vararg_integer) { + warning (e, "passing int consant into ... function"); } } } diff --git a/tools/qfcc/source/obj_file.c b/tools/qfcc/source/obj_file.c index eed5de4ce..a9f562984 100644 --- a/tools/qfcc/source/obj_file.c +++ b/tools/qfcc/source/obj_file.c @@ -434,7 +434,7 @@ qfo_byteswap_space (void *space, int size, qfos_type_t type) case qfos_type: case qfos_debug: for (val = (pr_type_t *) space, c = 0; c < size; c++, val++) - val->integer_var = LittleLong (val->integer_var); + val->int_var = LittleLong (val->int_var); break; } } @@ -696,7 +696,7 @@ get_def_type (qfo_t *qfo, pr_ptr_t type) case ty_enum: if (options.code.progsversion == PROG_ID_VERSION) return ev_float; - return ev_integer; + return ev_int; case ty_array: case ty_class: return ev_invalid; @@ -732,7 +732,7 @@ get_type_size (qfo_t *qfo, pr_ptr_t type) } return size; case ty_enum: - return pr_type_size[ev_integer]; + return pr_type_size[ev_int]; case ty_array: return type_def->array.size * get_type_size (qfo, type_def->array.type); @@ -781,7 +781,7 @@ get_type_alignment_log (qfo_t *qfo, pr_ptr_t type) } return alignment; case ty_enum: - return qfo_log2 (ev_types[ev_integer]->alignment); + return qfo_log2 (ev_types[ev_int]->alignment); case ty_array: return get_type_alignment_log (qfo, type_def->array.type); case ty_class: diff --git a/tools/qfcc/source/obj_type.c b/tools/qfcc/source/obj_type.c index 09927ecd3..d806e6c9b 100644 --- a/tools/qfcc/source/obj_type.c +++ b/tools/qfcc/source/obj_type.c @@ -214,7 +214,7 @@ qfo_encode_struct (type_t *type, defspace_t *space) if (i == num_fields) internal_error (0, "whoa, what happened?"); if (sym->sy_type == sy_const) - offset = sym->s.value->v.integer_val; + offset = sym->s.value->v.int_val; else offset = sym->s.offset; ENC_DEF (strct->fields[i].type, field_types[i]); diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index ee9722a2a..47accd2c3 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -241,11 +241,11 @@ v6p_opcode_init (void) // treats the operands of certain operands as integers // irrespective the progs version, so convert the engine's // view of the operands to the prog's view. - if (mop->type_a == ev_integer) + if (mop->type_a == ev_int) mop->type_a = ev_float; - if (mop->type_b == ev_integer) + if (mop->type_b == ev_int) mop->type_b = ev_float; - if (mop->type_c == ev_integer) + if (mop->type_c == ev_int) mop->type_c = ev_float; } Hash_AddElement (v6p_opcode_type_table, mop); diff --git a/tools/qfcc/source/pragma.c b/tools/qfcc/source/pragma.c index 60448815e..616198ab2 100644 --- a/tools/qfcc/source/pragma.c +++ b/tools/qfcc/source/pragma.c @@ -67,7 +67,7 @@ set_traditional (int traditional) options.traditional = 0; options.advanced = true; options.code.progsversion = PROG_V6P_VERSION; - type_default = &type_integer; + type_default = &type_int; break; case 1: options.traditional = 1; diff --git a/tools/qfcc/source/qc-lex.l b/tools/qfcc/source/qc-lex.l index 1a3cb9d99..c53965993 100644 --- a/tools/qfcc/source/qc-lex.l +++ b/tools/qfcc/source/qc-lex.l @@ -131,9 +131,9 @@ STRING \"(\\.|[^"\\])*\" else i = strtol (yytext, 0, 0); if (*c == 'u' || *c == 'U') - qc_yylval.expr = new_integer_expr (i);//FIXME + qc_yylval.expr = new_int_expr (i);//FIXME else - qc_yylval.expr = new_integer_expr (i); + qc_yylval.expr = new_int_expr (i); return VALUE; } @@ -208,7 +208,7 @@ STRING \"(\\.|[^"\\])*\" if (str[1]) warning (0, "multibyte char constant"); - qc_yylval.expr = new_integer_expr (*str); + qc_yylval.expr = new_int_expr (*str); return VALUE; } @@ -269,7 +269,7 @@ STRING \"(\\.|[^"\\])*\" "$"{s}*{FRAMEID} { int ret = do_grab (yytext); if (ret >= 0) { - qc_yylval.expr = new_integer_expr (ret); + qc_yylval.expr = new_int_expr (ret); return VALUE; } else { BEGIN (-ret); @@ -376,8 +376,8 @@ static keyword_t at_keywords[] = { static keyword_t qf_keywords[] = { {"quaternion", TYPE, &type_quaternion}, {"double", TYPE, &type_double}, - {"int", TYPE, &type_integer }, - {"unsigned", TYPE, &type_integer },//FIXME + {"int", TYPE, &type_int }, + {"unsigned", TYPE, &type_int },//FIXME {"@function", TYPE, &type_function }, {"@args", ARGS, 0 }, diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index 9c56a5790..454c8fcfc 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -969,11 +969,11 @@ abs_decl array_decl : '[' expr ']' { - if (!is_integer_val ($2) || expr_integer ($2) < 1) { + if (!is_int_val ($2) || expr_int ($2) < 1) { error (0, "invalid array size"); $$ = 0; } else { - $$ = expr_integer ($2); + $$ = expr_int ($2); } } | '[' ']' { $$ = 0; } @@ -1104,7 +1104,7 @@ non_code_func if (sym->s.def) sym->s.def->nosave |= spec.nosave; } else { - if (is_integer_val ($2) || is_float_val ($2)) { + if (is_int_val ($2) || is_float_val ($2)) { error (0, "invalid function initializer." " did you forget #?"); } else { diff --git a/tools/qfcc/source/qfcc.c b/tools/qfcc/source/qfcc.c index 2e656a21e..25c1a89c6 100644 --- a/tools/qfcc/source/qfcc.c +++ b/tools/qfcc/source/qfcc.c @@ -246,7 +246,7 @@ WriteProgs (dprograms_t *progs, int size) fielddefs[i].name = LittleLong (fielddefs[i].name); } for (i = 0; i < progs->numglobals; i++) - globals[i].integer_var = LittleLong (globals[i].integer_var); + globals[i].int_var = LittleLong (globals[i].int_var); if (!(h = Qopen (options.output_file, "wb"))) Sys_Error ("%s: %s\n", options.output_file, strerror(errno)); @@ -307,7 +307,7 @@ WriteSym (pr_debug_header_t *sym, int size) debug_defs[i].type_encoding = LittleLong (debug_defs[i].type_encoding); } for (i = 0; i < sym->debug_data_size; i++) { - debug_data[i].integer_var = LittleLong (debug_data[i].integer_var); + debug_data[i].int_var = LittleLong (debug_data[i].int_var); } if (!(h = Qopen (options.debug_file, "wb"))) @@ -441,9 +441,9 @@ finish_link (void) if (options.code.progsversion != PROG_ID_VERSION) { pr_int_t param_size = type_size (&type_param); pr_int_t param_alignment = qfo_log2 (type_param.alignment); - linker_add_def (".param_size", &type_integer, flags, + linker_add_def (".param_size", &type_int, flags, ¶m_size); - linker_add_def (".param_alignment", &type_integer, flags, + linker_add_def (".param_alignment", &type_int, flags, ¶m_alignment); linker_add_def (".xdefs", &type_xdefs, flags, 0); } diff --git a/tools/qfcc/source/qp-lex.l b/tools/qfcc/source/qp-lex.l index a57185209..7bb6d160b 100644 --- a/tools/qfcc/source/qp-lex.l +++ b/tools/qfcc/source/qp-lex.l @@ -113,7 +113,7 @@ FRAMEID {ID}(\.{ID})* i = strtol (yytext + 2, 0, 2); else i = strtol (yytext, 0, 0); - qp_yylval.expr = new_integer_expr (i); + qp_yylval.expr = new_int_expr (i); return VALUE; } @@ -170,7 +170,7 @@ FRAMEID {ID}(\.{ID})* "$"{s}*{FRAMEID} { int ret = do_grab (yytext); if (ret >= 0) { - qp_yylval.expr = new_integer_expr (ret); + qp_yylval.expr = new_int_expr (ret); return VALUE; } else { BEGIN (-ret); @@ -209,7 +209,7 @@ static keyword_t keywords[] = { {"vector", TYPE, &type_vector}, {"entity", TYPE, &type_entity}, {"quaternion", TYPE, &type_quaternion}, - {"integer", TYPE, &type_integer}, + {"integer", TYPE, &type_int}, {"program", PROGRAM, 0}, {"var", VAR, 0}, diff --git a/tools/qfcc/source/qp-parse.y b/tools/qfcc/source/qp-parse.y index b45e6d0ee..e7bb66647 100644 --- a/tools/qfcc/source/qp-parse.y +++ b/tools/qfcc/source/qp-parse.y @@ -148,7 +148,7 @@ build_dotmain (symbol_t *program) expr_t *exitcode; dotmain->params = 0; - dotmain->type = parse_params (&type_integer, 0); + dotmain->type = parse_params (&type_int, 0); dotmain->type = find_type (dotmain->type); dotmain = function_symbol (dotmain, 0, 1); @@ -198,7 +198,7 @@ program_head // FIXME need units and standard units { symbol_t *sym = new_symbol ("ExitCode"); - sym->type = &type_integer; + sym->type = &type_int; initialize_def (sym, 0, current_symtab->space, sc_global); if (sym->s.def) { sym->s.def->nosave = 1; @@ -245,7 +245,7 @@ type : standard_type | ARRAY '[' VALUE RANGE VALUE ']' OF standard_type { - $$ = based_array_type ($8, expr_integer ($3), expr_integer ($5)); + $$ = based_array_type ($8, expr_int ($3), expr_int ($5)); } ; @@ -480,7 +480,7 @@ name { if (!$1->table) { error (0, "%s undefined", $1->name); - $1->type = &type_integer; + $1->type = &type_int; symtab_addsymbol (current_symtab, $1); } $$ = new_symbol_expr ($1); diff --git a/tools/qfcc/source/reloc.c b/tools/qfcc/source/reloc.c index c1d471d0a..d235008d0 100644 --- a/tools/qfcc/source/reloc.c +++ b/tools/qfcc/source/reloc.c @@ -73,7 +73,7 @@ static const char *reloc_name[] = { "rel_def_field_ofs", }; -#define RELOC(r) (r)->space->data[(r)->offset].integer_var +#define RELOC(r) (r)->space->data[(r)->offset].int_var void relocate_refs (reloc_t *reloc, int offset) @@ -168,8 +168,8 @@ relocate_refs (reloc_t *reloc, int offset) break; case rel_def_field_ofs: //FIXME what is correct here? - //RELOC (reloc) += pr.data->data[offset].integer_var; - RELOC (reloc) += pr.near_data->data[offset].integer_var; + //RELOC (reloc) += pr.data->data[offset].int_var; + RELOC (reloc) += pr.near_data->data[offset].int_var; break; } reloc = reloc->next; diff --git a/tools/qfcc/source/shared.c b/tools/qfcc/source/shared.c index cee0d06c1..acdbf149f 100644 --- a/tools/qfcc/source/shared.c +++ b/tools/qfcc/source/shared.c @@ -72,7 +72,7 @@ check_undefined (symbol_t *sym) if (options.code.progsversion == PROG_ID_VERSION) sym->type = &type_float; else - sym->type = &type_integer; + sym->type = &type_int; } return sym; } diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 1c2cbc965..0d52f7c4e 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -155,13 +155,13 @@ operand_string (operand_t *op) case ev_field: return va (0, "field %d", op->value->v.pointer.val); case ev_entity: - return va (0, "ent %d", op->value->v.integer_val); + return va (0, "ent %d", op->value->v.int_val); case ev_func: - return va (0, "func %d", op->value->v.integer_val); - case ev_integer: - return va (0, "int %d", op->value->v.integer_val); - case ev_uinteger: - return va (0, "uint %u", op->value->v.uinteger_val); + return va (0, "func %d", op->value->v.int_val); + case ev_int: + return va (0, "int %d", op->value->v.int_val); + case ev_uint: + return va (0, "uint %u", op->value->v.uint_val); case ev_long: return va (0, "long %"PRIi64, op->value->v.long_val); case ev_ulong: @@ -237,11 +237,11 @@ _print_operand (operand_t *op) break; case ev_entity: case ev_func: - case ev_integer: - printf ("%d", op->value->v.integer_val); + case ev_int: + printf ("%d", op->value->v.int_val); break; - case ev_uinteger: - printf ("%u", op->value->v.uinteger_val); + case ev_uint: + printf ("%u", op->value->v.uint_val); break; case ev_long: printf ("%"PRIu64, op->value->v.long_val); @@ -804,7 +804,7 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) if ((src && src->op_type == op_nil) || src_expr->type == ex_nil) { // switch to memset because nil is type agnostic 0 and structures // can be any size - src_expr = new_integer_expr (0); + src_expr = new_int_expr (0); sblock = statement_subexpr (sblock, src_expr, &src); opcode_set = opcode_sets[1]; if (op) { @@ -853,7 +853,7 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) if (count < (1 << 16)) { count_expr = expr_file_line (new_short_expr (count), e); } else { - count_expr = expr_file_line (new_integer_expr (count), e); + count_expr = expr_file_line (new_int_expr (count), e); } sblock = statement_subexpr (sblock, count_expr, &size); @@ -1210,7 +1210,7 @@ expr_alias (sblock_t *sblock, expr_t *e, operand_t **op) int offset = 0; if (e->e.alias.offset) { - offset = expr_integer (e->e.alias.offset); + offset = expr_int (e->e.alias.offset); } type = e->e.alias.type; sblock = statement_subexpr (sblock, e->e.alias.expr, &aop); @@ -1473,9 +1473,9 @@ expr_nil (sblock_t *sblock, expr_t *e, operand_t **op) if (nil_size < 0x10000) { size_expr = new_short_expr (nil_size); } else { - size_expr = new_integer_expr (nil_size); + size_expr = new_int_expr (nil_size); } - sblock = statement_subexpr (sblock, new_integer_expr(0), &zero); + sblock = statement_subexpr (sblock, new_int_expr(0), &zero); sblock = statement_subexpr (sblock, size_expr, &size); s = new_statement (st_memset, "", e); @@ -1737,12 +1737,12 @@ statement_memset (sblock_t *sblock, expr_t *e) statement_t *s; if (is_constant (count)) { - if (is_integer (get_type (count)) - && (unsigned) expr_integer (count) < 0x10000) { - count = new_short_expr (expr_integer (count)); + if (is_int (get_type (count)) + && (unsigned) expr_int (count) < 0x10000) { + count = new_short_expr (expr_int (count)); } - if (is_uinteger (get_type (count)) && expr_integer (count) < 0x10000) { - count = new_short_expr (expr_uinteger (count)); + if (is_uint (get_type (count)) && expr_int (count) < 0x10000) { + count = new_short_expr (expr_uint (count)); } } s = new_statement (st_move, opcode, e); diff --git a/tools/qfcc/source/struct.c b/tools/qfcc/source/struct.c index 164a491a2..798696ac3 100644 --- a/tools/qfcc/source/struct.c +++ b/tools/qfcc/source/struct.c @@ -235,17 +235,17 @@ add_enum (symbol_t *enm, symbol_t *name, expr_t *val) name->type = enum_type; value = 0; if (enum_tab->symbols) - value = ((symbol_t *)(enum_tab->symtail))->s.value->v.integer_val + 1; + value = ((symbol_t *)(enum_tab->symtail))->s.value->v.int_val + 1; if (val) { convert_name (val); if (!is_constant (val)) error (val, "non-constant initializer"); - else if (!is_integer_val (val)) + else if (!is_int_val (val)) error (val, "invalid initializer type"); else - value = expr_integer (val); + value = expr_int (val); } - name->s.value = new_integer_val (value); + name->s.value = new_int_val (value); symtab_addsymbol (enum_tab, name); } @@ -263,12 +263,12 @@ enum_as_bool (type_t *enm, expr_t **zero, expr_t **one) for (sym = symtab->symbols; sym; sym = sym->next) { if (sym->sy_type != sy_const) continue; - val = sym->s.value->v.integer_val; + val = sym->s.value->v.int_val; if (!val) { zero_sym = sym; } else { if (one_sym) { - v = one_sym->s.value->v.integer_val; + v = one_sym->s.value->v.int_val; if (val * val > v * v) continue; } diff --git a/tools/qfcc/source/switch.c b/tools/qfcc/source/switch.c index f40d48d6d..9f245807a 100644 --- a/tools/qfcc/source/switch.c +++ b/tools/qfcc/source/switch.c @@ -136,14 +136,14 @@ case_label_expr (switch_block_t *switch_block, expr_t *value) if (!type_assignable (type, get_type (value))) return error (value, "type mismatch in case label"); if (is_integral (type) && is_integral (val_type)) { - value = new_integer_expr (expr_integer (value)); + value = new_int_expr (expr_int (value)); debug (value, "integeral label used in integral switch"); } else if (is_integral (type) && is_float (val_type)) { warning (value, "float label used in integral switch"); - value = new_integer_expr (expr_float (value)); + value = new_int_expr (expr_float (value)); } else if (is_float (type) && is_integral (val_type)) { debug (value, "integeral label used in float switch"); - value = new_float_expr (expr_integer (value)); + value = new_float_expr (expr_int (value)); } else if (is_float (type) && is_float (val_type)) { value = new_float_expr (expr_float (value)); debug (value, "float label used in float switch"); @@ -189,8 +189,8 @@ label_compare (const void *_a, const void *_b) return strcmp (s1, s2); } else if (is_float_val ((*a)->value)) { return expr_float ((*a)->value) - expr_float ((*b)->value); - } else if (is_integer_val ((*a)->value)) { - return expr_integer ((*a)->value) - expr_integer ((*b)->value); + } else if (is_int_val ((*a)->value)) { + return expr_int ((*a)->value) - expr_int ((*b)->value); } internal_error (0, "in switch"); } @@ -210,9 +210,9 @@ new_case_node (expr_t *low, expr_t *high) } else { int size; - if (!is_integer_val (low)) + if (!is_int_val (low)) internal_error (low, "switch"); - size = expr_integer (high) - expr_integer (low) + 1; + size = expr_int (high) - expr_int (low) + 1; node->labels = calloc (size, sizeof (expr_t *)); } node->left = node->right = 0; @@ -253,18 +253,18 @@ build_case_tree (case_label_t **labels, int count, int range) if (!nodes) Sys_Error ("out of memory"); - if (range && is_integer_val (labels[0]->value)) { + if (range && is_int_val (labels[0]->value)) { for (i = 0; i < count - 1; i = j, num_nodes++) { for (j = i + 1; j < count; j++) { - if (expr_integer (labels[j]->value) - - expr_integer (labels[j - 1]->value) > 1) + if (expr_int (labels[j]->value) + - expr_int (labels[j - 1]->value) > 1) break; } nodes[num_nodes] = new_case_node (labels[i]->value, labels[j - 1]->value); for (k = i; k < j; k++) - nodes[num_nodes]->labels[expr_integer (labels[k]->value) - - expr_integer (labels[i]->value)] + nodes[num_nodes]->labels[expr_int (labels[k]->value) + - expr_int (labels[i]->value)] = labels[k]->label; } if (i < count) { @@ -311,12 +311,12 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val, append_expr (sw, test); if (tree->low == tree->high) { - branch = branch_expr (EQ, new_alias_expr (&type_integer, temp), + branch = branch_expr (EQ, new_alias_expr (&type_int, temp), tree->labels[0]); append_expr (sw, branch); if (tree->left) { - branch = branch_expr (GT, new_alias_expr (&type_integer, temp), + branch = branch_expr (GT, new_alias_expr (&type_int, temp), high_label); append_expr (sw, branch); @@ -329,8 +329,8 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val, build_switch (sw, tree->right, op, sw_val, temp, default_label); } } else { - int low = expr_integer (tree->low); - int high = expr_integer (tree->high); + int low = expr_int (tree->low); + int high = expr_int (tree->high); symbol_t *table_sym; expr_t *table_expr; expr_t *table_init; @@ -346,7 +346,7 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val, append_element (table_init, new_element (label, 0)); } table_sym = new_symbol_type (table_name, - array_type (&type_integer, + array_type (&type_int, high - low + 1)); initialize_def (table_sym, table_init, pr.near_data, sc_static); table_expr = new_symbol_expr (table_sym); @@ -355,8 +355,8 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val, branch = branch_expr (LT, temp, low_label); append_expr (sw, branch); } - test = binary_expr (GT, cast_expr (&type_uinteger, temp), - cast_expr (&type_uinteger, range)); + test = binary_expr (GT, cast_expr (&type_uint, temp), + cast_expr (&type_uint, range)); branch = branch_expr (NE, test, high_label); append_expr (sw, branch); branch = jump_table_expr (table_expr, temp); @@ -382,7 +382,7 @@ check_enum_switch (switch_block_t *switch_block) for (enum_val = type->t.symtab->symbols; enum_val; enum_val = enum_val->next) { - cl.value = new_integer_expr (enum_val->s.value->v.integer_val); + cl.value = new_int_expr (enum_val->s.value->v.int_val); if (!Hash_FindElement (switch_block->labels, &cl)) { warning (switch_block->test, "enumeration value `%s' not handled in switch", @@ -446,7 +446,7 @@ switch_expr (switch_block_t *switch_block, expr_t *break_label, case_node_t *case_tree; if (is_string(type)) - temp = new_temp_def_expr (&type_integer); + temp = new_temp_def_expr (&type_int); else temp = new_temp_def_expr (type); case_tree = build_case_tree (labels, num_labels, is_integral (type)); diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index 17dd74571..81583de9c 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -75,8 +75,8 @@ type_t type_function = { ev_func, "function", 1, ty_basic, type_t type_pointer = { ev_pointer, "pointer", 1, ty_basic, {{&type_void}} }; type_t type_quaternion = { ev_quat, "quaternion", 4 }; -type_t type_integer = { ev_integer, "int", 1 }; -type_t type_uinteger = { ev_uinteger, "uint", 1 }; +type_t type_int = { ev_int, "int", 1 }; +type_t type_uint = { ev_uint, "uint", 1 }; type_t type_short = { ev_short, "short", 1 }; type_t type_double = { ev_double, "double", 2 }; @@ -106,8 +106,8 @@ type_t *ev_types[ev_type_count] = { &type_function, &type_pointer, &type_quaternion, - &type_integer, - &type_uinteger, + &type_int, + &type_uint, &type_short, &type_double, &type_invalid, @@ -186,8 +186,8 @@ free_type (type_t *type) case ev_entity: case ev_type_count: case ev_quat: - case ev_integer: - case ev_uinteger: + case ev_int: + case ev_uint: case ev_long: case ev_ulong: case ev_short: @@ -228,8 +228,8 @@ copy_chain (type_t *type, type_t *append) case ev_entity: case ev_type_count: case ev_quat: - case ev_integer: - case ev_uinteger: + case ev_int: + case ev_uint: case ev_long: case ev_ulong: case ev_short: @@ -281,8 +281,8 @@ append_type (type_t *type, type_t *new) case ev_entity: case ev_type_count: case ev_quat: - case ev_integer: - case ev_uinteger: + case ev_int: + case ev_uint: case ev_long: case ev_ulong: case ev_short: @@ -660,8 +660,8 @@ print_type_str (dstring_t *str, const type_t *type) case ev_vector: case ev_entity: case ev_quat: - case ev_integer: - case ev_uinteger: + case ev_int: + case ev_uint: case ev_long: case ev_ulong: case ev_short: @@ -822,10 +822,10 @@ encode_type (dstring_t *encoding, const type_t *type) case ev_quat: dasprintf (encoding, "Q"); return; - case ev_integer: + case ev_int: dasprintf (encoding, "i"); return; - case ev_uinteger: + case ev_uint: dasprintf (encoding, "I"); return; case ev_long: @@ -863,23 +863,23 @@ is_enum (const type_t *type) } int -is_integer (const type_t *type) +is_int (const type_t *type) { type = unalias_type (type); etype_t t = type->type; - if (t == ev_integer) + if (t == ev_int) return 1; return is_enum (type); } int -is_uinteger (const type_t *type) +is_uint (const type_t *type) { type = unalias_type (type); etype_t t = type->type; - if (t == ev_uinteger) + if (t == ev_uint) return 1; return is_enum (type); } @@ -899,7 +899,7 @@ int is_integral (const type_t *type) { type = unalias_type (type); - if (is_integer (type) || is_uinteger (type) || is_short (type)) + if (is_int (type) || is_uint (type) || is_short (type)) return 1; return is_enum (type); } @@ -1103,7 +1103,7 @@ type_size (const type_t *type) case ty_enum: if (!type->t.symtab) return 0; - return type_size (&type_integer); + return type_size (&type_int); case ty_array: return type->t.array.size * type_size (type->t.array.type); case ty_class: @@ -1138,8 +1138,8 @@ chain_basic_types (void) chain_type (&type_floatfield); if (!options.traditional) { chain_type (&type_quaternion); - chain_type (&type_integer); - chain_type (&type_uinteger); + chain_type (&type_int); + chain_type (&type_uint); chain_type (&type_short); chain_type (&type_double); } @@ -1175,10 +1175,10 @@ init_types (void) {"func_val", &type_function}, {"pointer_val", &type_pointer}, {"vector_val", &type_vector}, - {"int_val", &type_integer}, - {"uint_val", &type_uinteger}, - {"integer_val", &type_integer}, - {"uinteger_val", &type_uinteger}, + {"int_val", &type_int}, + {"uint_val", &type_uint}, + {"int_val", &type_int}, + {"uint_val", &type_uint}, {"quaternion_val", &type_quaternion}, {"double_val", &type_double}, {0, 0} @@ -1191,10 +1191,8 @@ init_types (void) {"field_val", &type_field}, {"func_val", &type_function}, {"pointer_val", &type_pointer}, - {"int_val", &type_integer}, - {"uint_val", &type_uinteger}, - {"integer_val", &type_integer}, - {"uinteger_val", &type_uinteger}, + {"int_val", &type_int}, + {"uint_val", &type_uint}, {"quaternion_val", &type_quaternion}, {"double_val", &type_double}, {0, 0} @@ -1212,7 +1210,7 @@ init_types (void) }; static struct_def_t type_encoding_struct[] = { {"types", &type_pointer}, - {"size", &type_integer}, + {"size", &type_int}, {0, 0} }; static struct_def_t xdef_struct[] = { @@ -1226,7 +1224,7 @@ init_types (void) {0, 0} }; static struct_def_t va_list_struct[] = { - {"count", &type_integer}, + {"count", &type_int}, {"list", 0}, // type will be filled in at runtime {0, 0} }; @@ -1234,7 +1232,7 @@ init_types (void) chain_basic_types (); type_nil = &type_quaternion; - type_default = &type_integer; + type_default = &type_int; if (options.code.progsversion == PROG_ID_VERSION) { // vector can't be part of .zero for v6 progs because for v6 progs, // .zero is only one word wide. diff --git a/tools/qfcc/source/value.c b/tools/qfcc/source/value.c index cd0af3d54..786a3d2fb 100644 --- a/tools/qfcc/source/value.c +++ b/tools/qfcc/source/value.c @@ -68,7 +68,7 @@ typedef struct { int func_val; ex_pointer_t pointer; float quaternion_val[4]; - int integer_val; + int int_val; double double_val; } i; } immediate_t; @@ -224,22 +224,22 @@ new_quaternion_val (const float *quaternion_val) } ex_value_t * -new_integer_val (int integer_val) +new_int_val (int int_val) { ex_value_t val; memset (&val, 0, sizeof (val)); - set_val_type (&val, &type_integer); - val.v.integer_val = integer_val; + set_val_type (&val, &type_int); + val.v.int_val = int_val; return find_value (&val); } ex_value_t * -new_uinteger_val (int uinteger_val) +new_uint_val (int uint_val) { ex_value_t val; memset (&val, 0, sizeof (val)); - set_val_type (&val, &type_uinteger); - val.v.uinteger_val = uinteger_val; + set_val_type (&val, &type_uint); + val.v.uint_val = uint_val; return find_value (&val); } @@ -277,7 +277,7 @@ static hashtab_t *field_imm_defs; static hashtab_t *func_imm_defs; static hashtab_t *pointer_imm_defs; static hashtab_t *quaternion_imm_defs; -static hashtab_t *integer_imm_defs; +static hashtab_t *int_imm_defs; static hashtab_t *double_imm_defs; static void @@ -296,15 +296,15 @@ imm_get_hash (const void *_imm, void *_tab) const char *str = pr.strings->strings + imm->i.string_val; return str ? Hash_String (str) : 0; } else if (tab == &float_imm_defs) { - return imm->i.integer_val; + return imm->i.int_val; } else if (tab == &vector_imm_defs) { return Hash_Buffer (&imm->i.vector_val, sizeof (&imm->i.vector_val)); } else if (tab == &entity_imm_defs) { - return imm->i.integer_val; + return imm->i.int_val; } else if (tab == &field_imm_defs) { return Hash_Buffer (&imm->i.pointer, sizeof (&imm->i.pointer)); } else if (tab == &func_imm_defs) { - return imm->i.integer_val; + return imm->i.int_val; } else if (tab == &pointer_imm_defs) { return Hash_Buffer (&imm->i.pointer, sizeof (&imm->i.pointer)); } else if (tab == &quaternion_imm_defs) { @@ -312,8 +312,8 @@ imm_get_hash (const void *_imm, void *_tab) sizeof (&imm->i.quaternion_val)); } else if (tab == &double_imm_defs) { return Hash_Buffer (&imm->i.double_val, sizeof (&imm->i.double_val)); - } else if (tab == &integer_imm_defs) { - return imm->i.integer_val; + } else if (tab == &int_imm_defs) { + return imm->i.int_val; } else { internal_error (0, 0); } @@ -348,8 +348,8 @@ imm_compare (const void *_imm1, const void *_imm2, void *_tab) return QuatCompare (imm1->i.quaternion_val, imm2->i.quaternion_val); } else if (tab == &double_imm_defs) { return imm1->i.double_val == imm2->i.double_val; - } else if (tab == &integer_imm_defs) { - return imm1->i.integer_val == imm2->i.integer_val; + } else if (tab == &int_imm_defs) { + return imm1->i.int_val == imm2->i.int_val; } else { internal_error (0, 0); } @@ -364,10 +364,10 @@ ReuseString (const char *str) static float value_as_float (ex_value_t *value) { - if (value->lltype == ev_uinteger) - return value->v.uinteger_val; - if (value->lltype == ev_integer) - return value->v.integer_val; + if (value->lltype == ev_uint) + return value->v.uint_val; + if (value->lltype == ev_int) + return value->v.int_val; if (value->lltype == ev_short) return value->v.short_val; if (value->lltype == ev_double) @@ -380,10 +380,10 @@ value_as_float (ex_value_t *value) static double value_as_double (ex_value_t *value) { - if (value->lltype == ev_uinteger) - return value->v.uinteger_val; - if (value->lltype == ev_integer) - return value->v.integer_val; + if (value->lltype == ev_uint) + return value->v.uint_val; + if (value->lltype == ev_int) + return value->v.int_val; if (value->lltype == ev_short) return value->v.short_val; if (value->lltype == ev_double) @@ -396,10 +396,10 @@ value_as_double (ex_value_t *value) static int value_as_int (ex_value_t *value) { - if (value->lltype == ev_uinteger) - return value->v.uinteger_val; - if (value->lltype == ev_integer) - return value->v.integer_val; + if (value->lltype == ev_uint) + return value->v.uint_val; + if (value->lltype == ev_int) + return value->v.int_val; if (value->lltype == ev_short) return value->v.short_val; if (value->lltype == ev_double) @@ -412,10 +412,10 @@ value_as_int (ex_value_t *value) static unsigned value_as_uint (ex_value_t *value) { - if (value->lltype == ev_uinteger) - return value->v.uinteger_val; - if (value->lltype == ev_integer) - return value->v.integer_val; + if (value->lltype == ev_uint) + return value->v.uint_val; + if (value->lltype == ev_int) + return value->v.int_val; if (value->lltype == ev_short) return value->v.short_val; if (value->lltype == ev_double) @@ -441,13 +441,13 @@ convert_value (ex_value_t *value, type_t *type) } else if (type->type == ev_short) { int val = value_as_int (value); return new_short_val (val); - } else if (type->type == ev_uinteger) { + } else if (type->type == ev_uint) { unsigned val = value_as_uint (value); - return new_uinteger_val (val); + return new_uint_val (val); } else { //FIXME handle enums separately? int val = value_as_int (value); - return new_integer_val (val); + return new_int_val (val); } } @@ -511,21 +511,21 @@ emit_value (ex_value_t *value, def_t *def) tab = pointer_imm_defs; type = &type_pointer; break; - case ev_integer: - case ev_uinteger: + case ev_int: + case ev_uint: if (!def || !is_float(def->type)) { - tab = integer_imm_defs; - type = &type_integer; + tab = int_imm_defs; + type = &type_int; break; } - val.v.float_val = val.v.integer_val; + val.v.float_val = val.v.int_val; val.lltype = ev_float; case ev_float: tab = float_imm_defs; type = &type_float; break; case ev_string: - val.v.integer_val = ReuseString (val.v.string_val); + val.v.int_val = ReuseString (val.v.string_val); tab = string_imm_defs; type = &type_string; break; @@ -637,7 +637,7 @@ clear_immediates (void) Hash_FlushTable (func_imm_defs); Hash_FlushTable (pointer_imm_defs); Hash_FlushTable (quaternion_imm_defs); - Hash_FlushTable (integer_imm_defs); + Hash_FlushTable (int_imm_defs); Hash_FlushTable (double_imm_defs); } else { value_table = Hash_NewTable (16381, 0, 0, 0, 0); @@ -675,9 +675,9 @@ clear_immediates (void) &quaternion_imm_defs, 0); Hash_SetHashCompare (quaternion_imm_defs, imm_get_hash, imm_compare); - integer_imm_defs = Hash_NewTable (16381, 0, imm_free, - &integer_imm_defs, 0); - Hash_SetHashCompare (integer_imm_defs, imm_get_hash, imm_compare); + int_imm_defs = Hash_NewTable (16381, 0, imm_free, + &int_imm_defs, 0); + Hash_SetHashCompare (int_imm_defs, imm_get_hash, imm_compare); double_imm_defs = Hash_NewTable (16381, 0, imm_free, &double_imm_defs, 0); @@ -691,5 +691,5 @@ clear_immediates (void) make_def_imm (def, float_imm_defs, &zero_val); make_def_imm (def, entity_imm_defs, &zero_val); make_def_imm (def, pointer_imm_defs, &zero_val); - make_def_imm (def, integer_imm_defs, &zero_val); + make_def_imm (def, int_imm_defs, &zero_val); } diff --git a/tools/qfcc/test/double-alias.r b/tools/qfcc/test/double-alias.r index 6050d2f6d..92eecd9c3 100644 --- a/tools/qfcc/test/double-alias.r +++ b/tools/qfcc/test/double-alias.r @@ -23,12 +23,12 @@ alias_printf (string fmt, ...) { int fail = 0; // this will fail on big-endian systems - fail = (@args.list[2].integer_val != 0x54442d18 - || @args.list[1].integer_val != 0x400921fb); + fail = (@args.list[2].int_val != 0x54442d18 + || @args.list[1].int_val != 0x400921fb); printf ("%g %08x%08x\n", - @args.list[0].integer_val, - @args.list[2].integer_val, - @args.list[1].integer_val); + @args.list[0].int_val, + @args.list[2].int_val, + @args.list[1].int_val); return fail; } diff --git a/tools/qfcc/test/typedef.r b/tools/qfcc/test/typedef.r index 9dbd7f40b..3755f63eb 100644 --- a/tools/qfcc/test/typedef.r +++ b/tools/qfcc/test/typedef.r @@ -26,7 +26,7 @@ check_alias (string name, qfot_type_t *alias) { if (alias.meta != ty_basic || alias.type != ev_pointer || alias.fldptr.aux_type.meta != ty_basic - || alias.fldptr.aux_type.type != ev_integer) { + || alias.fldptr.aux_type.type != ev_int) { printf ("%s is not a *int alias\n", name); return 0; } From 8a9911bf61a26c315207aaa2eb08150f051531f5 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 14:14:17 +0900 Subject: [PATCH 137/360] [build] Fix messed up progs include dir I'd missed adding progs/ to the paths. --- include/QF/Makemodule.am | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/include/QF/Makemodule.am b/include/QF/Makemodule.am index 76265bd70..407d0a358 100644 --- a/include/QF/Makemodule.am +++ b/include/QF/Makemodule.am @@ -132,11 +132,11 @@ include_qf_plugin = \ include/QF/plugin/vid_render.h include_qf_progs = \ - include/QF/pr_comp.h \ - include/QF/pr_debug.h \ - include/QF/pr_obj.h \ - include/QF/pr_type.h \ - include/QF/pr_type_names.h + include/QF/progs/pr_comp.h \ + include/QF/progs/pr_debug.h \ + include/QF/progs/pr_obj.h \ + include/QF/progs/pr_type.h \ + include/QF/progs/pr_type_names.h include_qf_scene = \ include/QF/scene/entity.h \ From 2f6c3c8ffb7b9e44886dae50e065df7596191dda Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 14:21:09 +0900 Subject: [PATCH 138/360] [ruamoko] Use pr_type_names.h for Ruamoko Keeping the two sets of definitions in sync has always been a pain. --- config.d/build_control.m4 | 2 ++ include/QF/Makemodule.am | 3 +++ ruamoko/include/types.h | 16 ++-------------- ruamoko/lib/types.r | 18 +++++------------- 4 files changed, 12 insertions(+), 27 deletions(-) diff --git a/config.d/build_control.m4 b/config.d/build_control.m4 index f55045a58..f3e59d2d5 100644 --- a/config.d/build_control.m4 +++ b/config.d/build_control.m4 @@ -316,9 +316,11 @@ if test "$ENABLE_tools_qfcc" = "yes" -a "$ENABLE_tools_pak" = "yes"; then QF_NEED(top, [ruamoko]) qfac_qfcc_include_qf="\$(qfcc_include_qf)" qfac_qfcc_include_qf_input="\$(qfcc_include_qf_input)" + qfac_qfcc_include_qf_progs="\$(qfcc_include_qf_progs)" fi QF_SUBST(qfac_qfcc_include_qf) QF_SUBST(qfac_qfcc_include_qf_input) +QF_SUBST(qfac_qfcc_include_qf_progs) if test x"${top_need_libs}" = xyes; then qfac_include_qf="\$(include_qf)" diff --git a/include/QF/Makemodule.am b/include/QF/Makemodule.am index 407d0a358..3892a430e 100644 --- a/include/QF/Makemodule.am +++ b/include/QF/Makemodule.am @@ -198,6 +198,7 @@ include_qf_vulkan = \ # headers shared with ruamoko qfcc_include_qf = include/QF/input.h +qfcc_include_qf_progs = include/QF/progs/pr_type_names.h qfcc_include_qf_input = \ include/QF/input/binding.h \ include/QF/input/imt.h @@ -225,8 +226,10 @@ qf_vulkan_include_HEADERS = @qfac_include_qf_vulkan@ ruamoko_qf_includedir = $(ruamoko_includedir)/QF ruamoko_qf_input_includedir = $(ruamoko_includedir)/QF/input +ruamoko_qf_progs_includedir = $(ruamoko_includedir)/QF/progs ruamoko_qf_include_HEADERS = @qfac_qfcc_include_qf@ ruamoko_qf_input_include_HEADERS = @qfac_qfcc_include_qf_input@ +ruamoko_qf_progs_include_HEADERS = @qfac_qfcc_include_qf_progs@ EXTRA_HEADERS += \ $(include_qf) \ diff --git a/ruamoko/include/types.h b/ruamoko/include/types.h index 7054eeead..2ff8a123e 100644 --- a/ruamoko/include/types.h +++ b/ruamoko/include/types.h @@ -1,21 +1,9 @@ #ifndef __types_h #define __types_h +#define EV_TYPE(type) ev_##type, typedef enum { - ev_void, - ev_string, - ev_float, - ev_vector, - ev_entity, - ev_field, - ev_func, - ev_pointer, // end of v6 types - ev_quat, - ev_int, - ev_uint, - ev_short, // value is embedded in the opcode - ev_double, - +#include ev_invalid, // invalid type. used for instruction checking ev_type_count // not a type, gives number of types } etype_t; diff --git a/ruamoko/lib/types.r b/ruamoko/lib/types.r index 45f51c70e..cecbe09bb 100644 --- a/ruamoko/lib/types.r +++ b/ruamoko/lib/types.r @@ -11,6 +11,7 @@ string ty_meta_name[7] = { "alias", }; +//FIXME use pr_type_names.h int pr_type_size[ev_type_count] = { 1, // ev_void 1, // ev_string @@ -25,22 +26,13 @@ int pr_type_size[ev_type_count] = { 1, // ev_uinteger 0, // ev_short value in opcode 2, // ev_double + 2, // ev_long + 2, // ev_ulong 0, // ev_invalid not a valid/simple type }; +#define EV_TYPE(type) #type, string pr_type_name[ev_type_count] = { - "void", - "string", - "float", - "vector", - "entity", - "field", - "function", - "pointer", - "quaternion", - "integer", - "uinteger", - "short", - "double", +#include "invalid", }; From afd1eb775bb9c47338a7b237ecc769b731685b7e Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 14:36:06 +0900 Subject: [PATCH 139/360] [gamecode] Rename ev_pointer to ev_ptr Rather short (no worse than ev_int, though) but more consistency is usually a good thing. --- include/QF/progs/pr_type.h | 4 +- include/QF/progs/pr_type_names.h | 2 +- libs/gamecode/opcodes.py | 2 +- libs/gamecode/pr_debug.c | 2 +- libs/gamecode/pr_v6p_opcode.c | 238 ++++++++++----------- libs/video/renderer/vulkan/vkgen/vkalias.r | 2 +- libs/video/renderer/vulkan/vkgen/vkgen.r | 2 +- libs/video/renderer/vulkan/vkgen/vktype.r | 8 +- nq/source/sv_progs.c | 2 +- qw/source/sv_progs.c | 2 +- ruamoko/lib/types.r | 2 +- ruamoko/qwaq/debugger/typeencodings.r | 2 +- tools/qfcc/source/class.c | 18 +- tools/qfcc/source/constfold.c | 32 +-- tools/qfcc/source/dags.c | 2 +- tools/qfcc/source/def.c | 2 +- tools/qfcc/source/dot_expr.c | 2 +- tools/qfcc/source/dot_type.c | 4 +- tools/qfcc/source/dump_globals.c | 4 +- tools/qfcc/source/expr.c | 21 +- tools/qfcc/source/expr_binary.c | 16 +- tools/qfcc/source/expr_bool.c | 2 +- tools/qfcc/source/flow.c | 2 +- tools/qfcc/source/obj_type.c | 2 +- tools/qfcc/source/statements.c | 8 +- tools/qfcc/source/type.c | 22 +- tools/qfcc/source/value.c | 6 +- tools/qfcc/test/typedef.r | 2 +- 28 files changed, 208 insertions(+), 205 deletions(-) diff --git a/include/QF/progs/pr_type.h b/include/QF/progs/pr_type.h index 328b2ff3e..02c591dfa 100644 --- a/include/QF/progs/pr_type.h +++ b/include/QF/progs/pr_type.h @@ -58,7 +58,7 @@ typedef struct qfot_alias_s { } qfot_alias_t; typedef struct qfot_fldptr_s { - etype_t type; ///< ev_field or ev_pointer + etype_t type; ///< ev_field or ev_ptr pr_ptr_t aux_type; ///< referenced type } qfot_fldptr_t; @@ -106,7 +106,7 @@ typedef struct qfot_type_s { pr_string_t encoding; ///< Objective-QC encoding union { etype_t type; ///< ty_basic: etype_t - qfot_fldptr_t fldptr; ///< ty_basic, ev_pointer/ev_field + qfot_fldptr_t fldptr; ///< ty_basic, ev_ptr/ev_field qfot_func_t func; ///< ty_basic, ev_func qfot_struct_t strct; ///< ty_struct/ty_union/ty_enum qfot_array_t array; ///< ty_array diff --git a/include/QF/progs/pr_type_names.h b/include/QF/progs/pr_type_names.h index ff190f2cd..712a3c74c 100644 --- a/include/QF/progs/pr_type_names.h +++ b/include/QF/progs/pr_type_names.h @@ -37,7 +37,7 @@ EV_TYPE(vector) EV_TYPE(entity) EV_TYPE(field) EV_TYPE(func) -EV_TYPE(pointer) // end of v6 types +EV_TYPE(ptr) // end of v6 types EV_TYPE(quat) EV_TYPE(int) EV_TYPE(uint) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 8734bb03c..f35067a7e 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -187,7 +187,7 @@ lea_formats = { "opname": "lea", "format": "{lea_fmt[mm]}", "widths": "0, 0, 1", - "types": "ev_pointer, ev_pointer, ev_pointer", + "types": "ev_ptr, ev_ptr, ev_ptr", "args": { "op_mode": "AECD", "lea_fmt": [ diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 9e0b1b363..16d584e88 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -1050,7 +1050,7 @@ value_string (pr_debug_data_t *data, qfot_type_t *type, pr_type_t *value) case ev_func: raw_type_view.func_view (type, value, data); break; - case ev_pointer: + case ev_ptr: raw_type_view.pointer_view (type, value, data); break; case ev_quat: diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index c61821852..934a6ed69 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -335,182 +335,182 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga.%Gb(%Ec), %gc", }, [OP_LOAD_P_v6p] = {".", "load.p", - ev_entity, ev_field, ev_pointer, + ev_entity, ev_field, ev_ptr, PROG_V6P_VERSION, "%Ga.%Gb(%Ec), %gc", }, [OP_LOADB_D_v6p] = {".", "loadb.d", - ev_pointer, ev_int, ev_double, + ev_ptr, ev_int, ev_double, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_F_v6p] = {".", "loadb.f", - ev_pointer, ev_int, ev_float, + ev_ptr, ev_int, ev_float, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_V_v6p] = {".", "loadb.v", - ev_pointer, ev_int, ev_vector, + ev_ptr, ev_int, ev_vector, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_Q_v6p] = {".", "loadb.q", - ev_pointer, ev_int, ev_quat, + ev_ptr, ev_int, ev_quat, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_S_v6p] = {".", "loadb.s", - ev_pointer, ev_int, ev_string, + ev_ptr, ev_int, ev_string, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_ENT_v6p] = {".", "loadb.ent", - ev_pointer, ev_int, ev_entity, + ev_ptr, ev_int, ev_entity, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_FLD_v6p] = {".", "loadb.fld", - ev_pointer, ev_int, ev_field, + ev_ptr, ev_int, ev_field, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_FN_v6p] = {".", "loadb.fn", - ev_pointer, ev_int, ev_func, + ev_ptr, ev_int, ev_func, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_I_v6p] = {".", "loadb.i", - ev_pointer, ev_int, ev_int, + ev_ptr, ev_int, ev_int, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADB_P_v6p] = {".", "loadb.p", - ev_pointer, ev_int, ev_pointer, + ev_ptr, ev_int, ev_ptr, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, [OP_LOADBI_D_v6p] = {".", "loadbi.d", - ev_pointer, ev_short, ev_double, + ev_ptr, ev_short, ev_double, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_F_v6p] = {".", "loadbi.f", - ev_pointer, ev_short, ev_float, + ev_ptr, ev_short, ev_float, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_V_v6p] = {".", "loadbi.v", - ev_pointer, ev_short, ev_vector, + ev_ptr, ev_short, ev_vector, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_Q_v6p] = {".", "loadbi.q", - ev_pointer, ev_short, ev_quat, + ev_ptr, ev_short, ev_quat, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_S_v6p] = {".", "loadbi.s", - ev_pointer, ev_short, ev_string, + ev_ptr, ev_short, ev_string, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_ENT_v6p] = {".", "loadbi.ent", - ev_pointer, ev_short, ev_entity, + ev_ptr, ev_short, ev_entity, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_FLD_v6p] = {".", "loadbi.fld", - ev_pointer, ev_short, ev_field, + ev_ptr, ev_short, ev_field, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_FN_v6p] = {".", "loadbi.fn", - ev_pointer, ev_short, ev_func, + ev_ptr, ev_short, ev_func, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_I_v6p] = {".", "loadbi.i", - ev_pointer, ev_short, ev_int, + ev_ptr, ev_short, ev_int, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_LOADBI_P_v6p] = {".", "loadbi.p", - ev_pointer, ev_short, ev_pointer, + ev_ptr, ev_short, ev_ptr, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, [OP_ADDRESS_v6p] = {"&", "address", - ev_entity, ev_field, ev_pointer, + ev_entity, ev_field, ev_ptr, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, [OP_ADDRESS_VOID_v6p] = {"&", "address", - ev_void, ev_invalid, ev_pointer, + ev_void, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_D_v6p] = {"&", "address.d", - ev_double, ev_invalid, ev_pointer, + ev_double, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_F_v6p] = {"&", "address.f", - ev_float, ev_invalid, ev_pointer, + ev_float, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_V_v6p] = {"&", "address.v", - ev_vector, ev_invalid, ev_pointer, + ev_vector, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_Q_v6p] = {"&", "address.q", - ev_quat, ev_invalid, ev_pointer, + ev_quat, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_S_v6p] = {"&", "address.s", - ev_string, ev_invalid, ev_pointer, + ev_string, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_ENT_v6p] = {"&", "address.ent", - ev_entity, ev_invalid, ev_pointer, + ev_entity, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_FLD_v6p] = {"&", "address.fld", - ev_field, ev_invalid, ev_pointer, + ev_field, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_FN_v6p] = {"&", "address.fn", - ev_func, ev_invalid, ev_pointer, + ev_func, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_I_v6p] = {"&", "address.i", - ev_int, ev_invalid, ev_pointer, + ev_int, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_ADDRESS_P_v6p] = {"&", "address.p", - ev_pointer, ev_invalid, ev_pointer, + ev_ptr, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, [OP_LEA_v6p] = {"&", "lea", - ev_pointer, ev_int, ev_pointer, + ev_ptr, ev_int, ev_ptr, PROG_V6P_VERSION, "(%Ga + %Gb), %gc", }, [OP_LEAI_v6p] = {"&", "leai", - ev_pointer, ev_short, ev_pointer, + ev_ptr, ev_short, ev_ptr, PROG_V6P_VERSION, "(%Ga + %sb), %gc", }, @@ -592,160 +592,160 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, %gb", }, [OP_STORE_P_v6p] = {"=", "store.p", - ev_pointer, ev_pointer, ev_invalid, + ev_ptr, ev_ptr, ev_invalid, PROG_V6P_VERSION, "%Ga, %gb", }, [OP_STOREP_D_v6p] = {".=", "storep.d", - ev_double, ev_pointer, ev_invalid, + ev_double, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, [OP_STOREP_F_v6p] = {".=", "storep.f", - ev_float, ev_pointer, ev_invalid, + ev_float, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, [OP_STOREP_V_v6p] = {".=", "storep.v", - ev_vector, ev_pointer, ev_invalid, + ev_vector, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, [OP_STOREP_Q_v6p] = {".=", "storep.q", - ev_quat, ev_pointer, ev_invalid, + ev_quat, ev_ptr, ev_invalid, PROG_V6P_VERSION, "%Ga, *%Gb", }, [OP_STOREP_S_v6p] = {".=", "storep.s", - ev_string, ev_pointer, ev_invalid, + ev_string, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, [OP_STOREP_ENT_v6p] = {".=", "storep.ent", - ev_entity, ev_pointer, ev_invalid, + ev_entity, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, [OP_STOREP_FLD_v6p] = {".=", "storep.fld", - ev_field, ev_pointer, ev_invalid, + ev_field, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, [OP_STOREP_FN_v6p] = {".=", "storep.fn", - ev_func, ev_pointer, ev_invalid, + ev_func, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, [OP_STOREP_I_v6p] = {".=", "storep.i", - ev_int, ev_pointer, ev_invalid, + ev_int, ev_ptr, ev_invalid, PROG_V6P_VERSION, "%Ga, *%Gb", }, [OP_STOREP_P_v6p] = {".=", "storep.p", - ev_pointer, ev_pointer, ev_invalid, + ev_ptr, ev_ptr, ev_invalid, PROG_V6P_VERSION, "%Ga, *%Gb", }, [OP_STOREB_D_v6p] = {".=", "storeb.d", - ev_double, ev_pointer, ev_int, + ev_double, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_F_v6p] = {".=", "storeb.f", - ev_float, ev_pointer, ev_int, + ev_float, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_V_v6p] = {".=", "storeb.v", - ev_vector, ev_pointer, ev_int, + ev_vector, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_Q_v6p] = {".=", "storeb.q", - ev_quat, ev_pointer, ev_int, + ev_quat, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_S_v6p] = {".=", "storeb.s", - ev_string, ev_pointer, ev_int, + ev_string, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_ENT_v6p] = {".=", "storeb.ent", - ev_entity, ev_pointer, ev_int, + ev_entity, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_FLD_v6p] = {".=", "storeb.fld", - ev_field, ev_pointer, ev_int, + ev_field, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_FN_v6p] = {".=", "storeb.fn", - ev_func, ev_pointer, ev_int, + ev_func, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_I_v6p] = {".=", "storeb.i", - ev_int, ev_pointer, ev_int, + ev_int, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_P_v6p] = {".=", "storeb.p", - ev_pointer, ev_pointer, ev_int, + ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, [OP_STOREBI_D_v6p] = {".=", "storebi.d", - ev_double, ev_pointer, ev_short, + ev_double, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_F_v6p] = {".=", "storebi.f", - ev_float, ev_pointer, ev_short, + ev_float, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_V_v6p] = {".=", "storebi.v", - ev_vector, ev_pointer, ev_short, + ev_vector, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_Q_v6p] = {".=", "storebi.q", - ev_quat, ev_pointer, ev_short, + ev_quat, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_S_v6p] = {".=", "storebi.s", - ev_string, ev_pointer, ev_short, + ev_string, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_ENT_v6p] = {".=", "storebi.ent", - ev_entity, ev_pointer, ev_short, + ev_entity, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_FLD_v6p] = {".=", "storebi.fld", - ev_field, ev_pointer, ev_short, + ev_field, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_FN_v6p] = {".=", "storebi.fn", - ev_func, ev_pointer, ev_short, + ev_func, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_I_v6p] = {".=", "storebi.i", - ev_int, ev_pointer, ev_short, + ev_int, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_P_v6p] = {".=", "storebi.p", - ev_pointer, ev_pointer, ev_short, + ev_ptr, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, @@ -798,7 +798,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, %gc", }, [OP_NOT_P_v6p] = {"!", "not.p", - ev_pointer, ev_invalid, ev_int, + ev_ptr, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, @@ -1112,27 +1112,27 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_GE_P_v6p] = {">=", "ge.p", - ev_pointer, ev_pointer, ev_int, + ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, }, [OP_LE_P_v6p] = {"<=", "le.p", - ev_pointer, ev_pointer, ev_int, + ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, }, [OP_GT_P_v6p] = {">", "gt.p", - ev_pointer, ev_pointer, ev_int, + ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, }, [OP_LT_P_v6p] = {"<", "lt.p", - ev_pointer, ev_pointer, ev_int, + ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, }, [OP_EQ_P_v6p] = {"==", "eq.p", - ev_pointer, ev_pointer, ev_int, + ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, }, [OP_NE_P_v6p] = {"!=", "ne.p", - ev_pointer, ev_pointer, ev_int, + ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, }, @@ -1142,12 +1142,12 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, %sb, %gc", }, [OP_MOVEP_v6p] = {"", "movep", - ev_pointer, ev_int, ev_pointer, + ev_ptr, ev_int, ev_ptr, PROG_V6P_VERSION, "%Ga, %Gb, %Gc", }, [OP_MOVEPI_v6p] = {"", "movepi", - ev_pointer, ev_short, ev_pointer, + ev_ptr, ev_short, ev_ptr, PROG_V6P_VERSION, "%Ga, %sb, %Gc", }, @@ -1157,12 +1157,12 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, %sb, %gc", }, [OP_MEMSETP_v6p] = {"", "memsetp", - ev_int, ev_int, ev_pointer, + ev_int, ev_int, ev_ptr, PROG_V6P_VERSION, "%Ga, %Gb, %Gc", }, [OP_MEMSETPI_v6p] = {"", "memsetpi", - ev_int, ev_short, ev_pointer, + ev_int, ev_short, ev_ptr, PROG_V6P_VERSION, "%Ga, %sb, %Gc", }, @@ -1198,7 +1198,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga", }, [OP_PUSH_P_v6p] = {"", "push.p", - ev_pointer, ev_invalid, ev_invalid, + ev_ptr, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, @@ -1219,103 +1219,103 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_PUSHB_S_v6p] = {"", "pushb.s", - ev_pointer, ev_int, ev_string, + ev_ptr, ev_int, ev_string, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_F_v6p] = {"", "pushb.f", - ev_pointer, ev_int, ev_float, + ev_ptr, ev_int, ev_float, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_V_v6p] = {"", "pushb.v", - ev_pointer, ev_int, ev_vector, + ev_ptr, ev_int, ev_vector, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_ENT_v6p] = {"", "pushb.ent", - ev_pointer, ev_int, ev_entity, + ev_ptr, ev_int, ev_entity, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_FLD_v6p] = {"", "pushb.fld", - ev_pointer, ev_int, ev_field, + ev_ptr, ev_int, ev_field, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_FN_v6p] = {"", "pushb.fn", - ev_pointer, ev_int, ev_func, + ev_ptr, ev_int, ev_func, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_P_v6p] = {"", "pushb.p", - ev_pointer, ev_int, ev_pointer, + ev_ptr, ev_int, ev_ptr, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_Q_v6p] = {"", "pushb.q", - ev_pointer, ev_int, ev_quat, + ev_ptr, ev_int, ev_quat, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_I_v6p] = {"", "pushb.i", - ev_pointer, ev_int, ev_int, + ev_ptr, ev_int, ev_int, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHB_D_v6p] = {"", "pushb.d", - ev_pointer, ev_int, ev_double, + ev_ptr, ev_int, ev_double, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_PUSHBI_S_v6p] = {"", "pushbi.s", - ev_pointer, ev_short, ev_string, + ev_ptr, ev_short, ev_string, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_F_v6p] = {"", "pushbi.f", - ev_pointer, ev_short, ev_float, + ev_ptr, ev_short, ev_float, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_V_v6p] = {"", "pushbi.v", - ev_pointer, ev_short, ev_vector, + ev_ptr, ev_short, ev_vector, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_ENT_v6p] = {"", "pushbi.ent", - ev_pointer, ev_short, ev_entity, + ev_ptr, ev_short, ev_entity, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_FLD_v6p] = {"", "pushbi.fld", - ev_pointer, ev_short, ev_field, + ev_ptr, ev_short, ev_field, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_FN_v6p] = {"", "pushbi.fn", - ev_pointer, ev_short, ev_func, + ev_ptr, ev_short, ev_func, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_P_v6p] = {"", "pushbi.p", - ev_pointer, ev_short, ev_pointer, + ev_ptr, ev_short, ev_ptr, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_Q_v6p] = {"", "pushbi.q", - ev_pointer, ev_short, ev_quat, + ev_ptr, ev_short, ev_quat, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_I_v6p] = {"", "pushbi.i", - ev_pointer, ev_short, ev_int, + ev_ptr, ev_short, ev_int, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_PUSHBI_D_v6p] = {"", "pushbi.d", - ev_pointer, ev_short, ev_double, + ev_ptr, ev_short, ev_double, PROG_V6P_VERSION, "*(%Ga + %sb)", }, @@ -1351,7 +1351,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%ga", }, [OP_POP_P_v6p] = {"", "pop.p", - ev_pointer, ev_invalid, ev_invalid, + ev_ptr, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%ga", }, @@ -1372,103 +1372,103 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { }, [OP_POPB_S_v6p] = {"", "popb.s", - ev_pointer, ev_int, ev_string, + ev_ptr, ev_int, ev_string, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_F_v6p] = {"", "popb.f", - ev_pointer, ev_int, ev_float, + ev_ptr, ev_int, ev_float, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_V_v6p] = {"", "popb.v", - ev_pointer, ev_int, ev_vector, + ev_ptr, ev_int, ev_vector, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_ENT_v6p] = {"", "popb.ent", - ev_pointer, ev_int, ev_entity, + ev_ptr, ev_int, ev_entity, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_FLD_v6p] = {"", "popb.fld", - ev_pointer, ev_int, ev_field, + ev_ptr, ev_int, ev_field, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_FN_v6p] = {"", "popb.fn", - ev_pointer, ev_int, ev_func, + ev_ptr, ev_int, ev_func, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_P_v6p] = {"", "popb.p", - ev_pointer, ev_int, ev_pointer, + ev_ptr, ev_int, ev_ptr, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_Q_v6p] = {"", "popb.q", - ev_pointer, ev_int, ev_quat, + ev_ptr, ev_int, ev_quat, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_I_v6p] = {"", "popb.i", - ev_pointer, ev_int, ev_int, + ev_ptr, ev_int, ev_int, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPB_D_v6p] = {"", "popb.d", - ev_pointer, ev_int, ev_double, + ev_ptr, ev_int, ev_double, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, [OP_POPBI_S_v6p] = {"", "popbi.s", - ev_pointer, ev_short, ev_string, + ev_ptr, ev_short, ev_string, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_F_v6p] = {"", "popbi.f", - ev_pointer, ev_short, ev_float, + ev_ptr, ev_short, ev_float, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_V_v6p] = {"", "popbi.v", - ev_pointer, ev_short, ev_vector, + ev_ptr, ev_short, ev_vector, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_ENT_v6p] = {"", "popbi.ent", - ev_pointer, ev_short, ev_entity, + ev_ptr, ev_short, ev_entity, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_FLD_v6p] = {"", "popbi.fld", - ev_pointer, ev_short, ev_field, + ev_ptr, ev_short, ev_field, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_FN_v6p] = {"", "popbi.fn", - ev_pointer, ev_short, ev_func, + ev_ptr, ev_short, ev_func, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_P_v6p] = {"", "popbi.p", - ev_pointer, ev_short, ev_pointer, + ev_ptr, ev_short, ev_ptr, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_Q_v6p] = {"", "popbi.q", - ev_pointer, ev_short, ev_quat, + ev_ptr, ev_short, ev_quat, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_I_v6p] = {"", "popbi.i", - ev_pointer, ev_short, ev_int, + ev_ptr, ev_short, ev_int, PROG_V6P_VERSION, "*(%Ga + %sb)", }, [OP_POPBI_D_v6p] = {"", "popbi.d", - ev_pointer, ev_short, ev_double, + ev_ptr, ev_short, ev_double, PROG_V6P_VERSION, "*(%Ga + %sb)", }, diff --git a/libs/video/renderer/vulkan/vkgen/vkalias.r b/libs/video/renderer/vulkan/vkgen/vkalias.r index e0aad2943..bbb7ffb21 100644 --- a/libs/video/renderer/vulkan/vkgen/vkalias.r +++ b/libs/video/renderer/vulkan/vkgen/vkalias.r @@ -33,7 +33,7 @@ } else if ([alias class] == [Enum class] || [alias class] == [Struct class]) { [alias addToQueue]; - } else if (alias.type.meta == ty_basic && alias.type.type == ev_pointer) { + } else if (alias.type.meta == ty_basic && alias.type.type == ev_ptr) { Type *type = [Type findType:alias.type.fldptr.aux_type]; if (!type) { // pointer to opaque struct. Probably diff --git a/libs/video/renderer/vulkan/vkgen/vkgen.r b/libs/video/renderer/vulkan/vkgen/vkgen.r index 4bcd74ee4..a3a5e426f 100644 --- a/libs/video/renderer/vulkan/vkgen/vkgen.r +++ b/libs/video/renderer/vulkan/vkgen/vkgen.r @@ -66,7 +66,7 @@ void print_type (qfot_type_t *type) case ty_basic: //printf (" %d", type.type); switch (type.type) { - case ev_pointer: + case ev_ptr: case ev_field: //printf (" "); print_type (type.fldptr.aux_type); diff --git a/libs/video/renderer/vulkan/vkgen/vktype.r b/libs/video/renderer/vulkan/vkgen/vktype.r index aa32f3a41..70de1fbc7 100644 --- a/libs/video/renderer/vulkan/vkgen/vktype.r +++ b/libs/video/renderer/vulkan/vkgen/vktype.r @@ -89,7 +89,7 @@ static string get_type_key (void *type, void *unused) -(void) addToQueue { string name = [self name]; - if (type.meta == ty_basic && type.type == ev_pointer) { + if (type.meta == ty_basic && type.type == ev_ptr) { [[Type findType: type.fldptr.aux_type] addToQueue]; } } @@ -134,7 +134,7 @@ static string get_type_key (void *type, void *unused) -(int) isPointer { if ((type.meta == ty_basic || type.meta == ty_alias) - && type.type == ev_pointer) { + && type.type == ev_ptr) { return 1; } return 0; @@ -143,10 +143,10 @@ static string get_type_key (void *type, void *unused) -(Type *) dereference { qfot_type_t *t = type; - if (t.meta == ty_alias && t.type == ev_pointer) { + if (t.meta == ty_alias && t.type == ev_ptr) { t = type.alias.full_type; } - if (t.meta == ty_basic && t.type == ev_pointer) { + if (t.meta == ty_basic && t.type == ev_ptr) { t = type.fldptr.aux_type; } return [Type findType:t]; diff --git a/nq/source/sv_progs.c b/nq/source/sv_progs.c index 5c94f8080..65c7ee495 100644 --- a/nq/source/sv_progs.c +++ b/nq/source/sv_progs.c @@ -354,7 +354,7 @@ set_address (sv_def_t *def, void *address) case ev_entity: case ev_field: case ev_func: - case ev_pointer: + case ev_ptr: case ev_int: case ev_uint: *(pr_int_t **)def->field = (pr_int_t *) address; diff --git a/qw/source/sv_progs.c b/qw/source/sv_progs.c index 8937e7fc8..4510ee339 100644 --- a/qw/source/sv_progs.c +++ b/qw/source/sv_progs.c @@ -387,7 +387,7 @@ set_address (sv_def_t *def, void *address) case ev_entity: case ev_field: case ev_func: - case ev_pointer: + case ev_ptr: case ev_int: case ev_uint: *(pr_int_t **)def->field = (pr_int_t *) address; diff --git a/ruamoko/lib/types.r b/ruamoko/lib/types.r index cecbe09bb..f732cc8d0 100644 --- a/ruamoko/lib/types.r +++ b/ruamoko/lib/types.r @@ -20,7 +20,7 @@ int pr_type_size[ev_type_count] = { 1, // ev_entity 1, // ev_field 1, // ev_func - 1, // ev_pointer + 1, // ev_ptr 4, // ev_quat 1, // ev_integer 1, // ev_uinteger diff --git a/ruamoko/qwaq/debugger/typeencodings.r b/ruamoko/qwaq/debugger/typeencodings.r index 64429b273..fe296a573 100644 --- a/ruamoko/qwaq/debugger/typeencodings.r +++ b/ruamoko/qwaq/debugger/typeencodings.r @@ -106,7 +106,7 @@ static void type_free (void *t, void *unused) } switch (type.meta) { case ty_basic: - if (type.type == ev_pointer || type.type == ev_field) { + if (type.type == ev_ptr || type.type == ev_field) { t = [TypeEncodings getType:(unsigned)type.fldptr.aux_type fromTarget:target]; if (!t) { diff --git a/tools/qfcc/source/class.c b/tools/qfcc/source/class.c index de0d473e6..b821135a7 100644 --- a/tools/qfcc/source/class.c +++ b/tools/qfcc/source/class.c @@ -72,12 +72,12 @@ static hashtab_t *static_instance_classes; // these will be built up further type_t type_selector = { ev_invalid, 0, 0, ty_struct}; -type_t type_SEL = { ev_pointer, "SEL", 1, ty_basic, {{&type_selector}}}; +type_t type_SEL = { ev_ptr, "SEL", 1, ty_basic, {{&type_selector}}}; type_t *IMP_params[] = {&type_id, &type_SEL}; type_t type_IMP = { ev_func, "IMP", 1, ty_basic, {{&type_id, -3, IMP_params}}}; type_t type_super = { ev_invalid, 0, 0 }; -type_t type_SuperPtr = { ev_pointer, 0, 1, ty_basic, {{&type_super}}}; +type_t type_SuperPtr = { ev_ptr, 0, 1, ty_basic, {{&type_super}}}; type_t *supermsg_params[] = {&type_SuperPtr, &type_SEL}; type_t type_supermsg = { ev_func, ".supermsg", 1, ty_basic, {{&type_id, -3, supermsg_params}}}; @@ -86,7 +86,7 @@ type_t type_method_description = { ev_invalid, 0, 0, ty_struct }; type_t type_category = { ev_invalid, 0, 0, ty_struct}; type_t type_ivar = { ev_invalid, 0, 0, ty_struct}; type_t type_module = { ev_invalid, 0, 0, ty_struct}; -type_t type_moduleptr = { ev_pointer, 0, 1, ty_basic, {{&type_module}}}; +type_t type_moduleptr = { ev_ptr, 0, 1, ty_basic, {{&type_module}}}; type_t *obj_exec_class_params[] = { &type_moduleptr }; type_t type_exec_class = { ev_func, 0, 1, ty_basic, {{&type_void, 1, obj_exec_class_params}}}; @@ -94,9 +94,9 @@ type_t type_exec_class = { ev_func, 0, 1, ty_basic, // are never misidentified as id. It will be set to the correct value // when the obj system is initialized. type_t type_object = {ev_invalid, 0, 0, ty_struct, {{(type_t *)1}}}; -type_t type_id = { ev_pointer, "id", 1, ty_basic, {{&type_object}}}; +type_t type_id = { ev_ptr, "id", 1, ty_basic, {{&type_object}}}; type_t type_class = { ev_invalid, 0, 0, ty_struct}; -type_t type_Class = { ev_pointer, 0, 1, ty_basic, {{&type_class}}}; +type_t type_Class = { ev_ptr, 0, 1, ty_basic, {{&type_class}}}; type_t type_protocol = { ev_invalid, 0, 0, ty_struct}; int obj_initialized = 0; @@ -229,7 +229,7 @@ emit_instance_defs (def_t *def, void *data, int index) { obj_static_instances_data_t *da = (obj_static_instances_data_t *)data; - if (!is_array (def->type) || def->type->t.array.type->type != ev_pointer) + if (!is_array (def->type) || def->type->t.array.type->type != ev_ptr) internal_error (0, "%s: expected array of pointers def", __FUNCTION__); if (index < 0 || index >= da->num_instances + 1) internal_error (0, "%s: out of bounds index: %d %d", @@ -325,7 +325,7 @@ is_id (const type_t *type) return 1; // type may be a qualified id, in which case it will be a pointer to // a qualified obj_object struct - if (type->type != ev_pointer) + if (type->type != ev_ptr) return 0; if (!is_struct (type->t.fldptr.type)) return 0; @@ -357,7 +357,7 @@ is_classptr (const type_t *type) // easy cases first :) if (is_id (type) || is_Class (type)) return 1; - if (type->type != ev_pointer) + if (type->type != ev_ptr) return 0; type = type->t.fldptr.type; if (is_class (type)) @@ -1455,7 +1455,7 @@ emit_symtab_defs (def_t *def, void *data, int index) { obj_symtab_data_t *da = (obj_symtab_data_t *)data; - if (!is_array (def->type) || def->type->t.array.type->type != ev_pointer) + if (!is_array (def->type) || def->type->t.array.type->type != ev_ptr) internal_error (0, "%s: expected array of pointers def", __FUNCTION__); if (index < 0 || index >= da->cls_def_cnt + da->cat_def_cnt + 1) internal_error (0, "%s: out of bounds index: %d %d", diff --git a/tools/qfcc/source/constfold.c b/tools/qfcc/source/constfold.c index 20a9c5716..8566e00b1 100644 --- a/tools/qfcc/source/constfold.c +++ b/tools/qfcc/source/constfold.c @@ -1060,7 +1060,7 @@ static operation_t op_void[ev_type_count] = { do_op_invalid, // ev_entity do_op_invalid, // ev_field do_op_invalid, // ev_func - do_op_invalid, // ev_pointer + do_op_invalid, // ev_ptr do_op_invalid, // ev_quaternion do_op_invalid, // ev_int do_op_invalid, // ev_uint @@ -1079,7 +1079,7 @@ static operation_t op_string[ev_type_count] = { do_op_invalid, // ev_entity do_op_invalid, // ev_field do_op_invalid, // ev_func - do_op_invalid, // ev_pointer + do_op_invalid, // ev_ptr do_op_invalid, // ev_quaternion do_op_invalid, // ev_int do_op_invalid, // ev_uint @@ -1098,7 +1098,7 @@ static operation_t op_float[ev_type_count] = { do_op_invalid, // ev_entity do_op_invalid, // ev_field do_op_invalid, // ev_func - do_op_invalid, // ev_pointer + do_op_invalid, // ev_ptr do_op_quaternion, // ev_quaternion do_op_float, // ev_int do_op_float, // ev_uint @@ -1117,7 +1117,7 @@ static operation_t op_vector[ev_type_count] = { do_op_invalid, // ev_entity do_op_invalid, // ev_field do_op_invalid, // ev_func - do_op_invalid, // ev_pointer + do_op_invalid, // ev_ptr do_op_invalid, // ev_quaternion do_op_vector, // ev_int do_op_vector, // ev_uint @@ -1136,7 +1136,7 @@ static operation_t op_entity[ev_type_count] = { do_op_entity, // ev_entity do_op_entity, // ev_field do_op_invalid, // ev_func - do_op_invalid, // ev_pointer + do_op_invalid, // ev_ptr do_op_invalid, // ev_quaternion do_op_invalid, // ev_int do_op_invalid, // ev_uint @@ -1155,7 +1155,7 @@ static operation_t op_field[ev_type_count] = { do_op_invalid, // ev_entity do_op_field, // ev_field do_op_invalid, // ev_func - do_op_invalid, // ev_pointer + do_op_invalid, // ev_ptr do_op_invalid, // ev_quaternion do_op_invalid, // ev_int do_op_invalid, // ev_uint @@ -1174,7 +1174,7 @@ static operation_t op_func[ev_type_count] = { do_op_func, // ev_entity do_op_func, // ev_field do_op_func, // ev_func - do_op_func, // ev_pointer + do_op_func, // ev_ptr do_op_func, // ev_quaternion do_op_func, // ev_int do_op_func, // ev_uint @@ -1193,7 +1193,7 @@ static operation_t op_pointer[ev_type_count] = { do_op_pointer, // ev_entity do_op_pointer, // ev_field do_op_pointer, // ev_func - do_op_pointer, // ev_pointer + do_op_pointer, // ev_ptr do_op_pointer, // ev_quaternion do_op_pointer, // ev_int do_op_pointer, // ev_uint @@ -1212,7 +1212,7 @@ static operation_t op_quaternion[ev_type_count] = { do_op_invalid, // ev_entity do_op_invalid, // ev_field do_op_invalid, // ev_func - do_op_invalid, // ev_pointer + do_op_invalid, // ev_ptr do_op_quaternion, // ev_quaternion do_op_quaternion, // ev_int do_op_quaternion, // ev_uint @@ -1231,7 +1231,7 @@ static operation_t op_int[ev_type_count] = { do_op_invalid, // ev_entity do_op_invalid, // ev_field do_op_invalid, // ev_func - do_op_invalid, // ev_pointer + do_op_invalid, // ev_ptr do_op_quaternion, // ev_quaternion do_op_int, // ev_int do_op_uint, // ev_uint @@ -1250,7 +1250,7 @@ static operation_t op_uint[ev_type_count] = { do_op_invalid, // ev_entity do_op_invalid, // ev_field do_op_invalid, // ev_func - do_op_invalid, // ev_pointer + do_op_invalid, // ev_ptr do_op_quaternion, // ev_quaternion do_op_uint, // ev_int do_op_uint, // ev_uint @@ -1269,7 +1269,7 @@ static operation_t op_short[ev_type_count] = { do_op_invalid, // ev_entity do_op_invalid, // ev_field do_op_invalid, // ev_func - do_op_invalid, // ev_pointer + do_op_invalid, // ev_ptr do_op_quaternion, // ev_quaternion do_op_int, // ev_int do_op_uint, // ev_uint @@ -1288,7 +1288,7 @@ static operation_t op_double[ev_type_count] = { do_op_invalid, // ev_entity do_op_invalid, // ev_field do_op_invalid, // ev_func - do_op_invalid, // ev_pointer + do_op_invalid, // ev_ptr do_op_quaternion, // ev_quaternion do_op_int, // ev_int do_op_uint, // ev_uint @@ -1307,7 +1307,7 @@ static operation_t op_compound[ev_type_count] = { do_op_invalid, // ev_entity do_op_invalid, // ev_field do_op_invalid, // ev_func - do_op_invalid, // ev_pointer + do_op_invalid, // ev_ptr do_op_invalid, // ev_quaternion do_op_compound, // ev_int do_op_compound, // ev_uint @@ -1326,7 +1326,7 @@ static operation_t *do_op[ev_type_count] = { op_entity, // ev_entity op_field, // ev_field op_func, // ev_func - op_pointer, // ev_pointer + op_pointer, // ev_ptr op_quaternion, // ev_quaternion op_int, // ev_int op_uint, // ev_uint @@ -1658,7 +1658,7 @@ static unaryop_t do_unary_op[ev_type_count] = { uop_entity, // ev_entity uop_field, // ev_field uop_func, // ev_func - uop_pointer, // ev_pointer + uop_pointer, // ev_ptr uop_quaternion, // ev_quaternion uop_int, // ev_int uop_uint, // ev_uint diff --git a/tools/qfcc/source/dags.c b/tools/qfcc/source/dags.c index 9e3b1cdab..9c7746bea 100644 --- a/tools/qfcc/source/dags.c +++ b/tools/qfcc/source/dags.c @@ -427,7 +427,7 @@ dagnode_set_edges (dag_t *dag, dagnode_t *n) set_add (node->edges, n->number); } if (op->op_type == op_value - && op->value->lltype == ev_pointer + && op->value->lltype == ev_ptr && op->value->v.pointer.def) { def_visit_all (op->value->v.pointer.def, 1, dagnode_def_set_edges_visit, n); diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c index cf854a1b4..449db7320 100644 --- a/tools/qfcc/source/def.c +++ b/tools/qfcc/source/def.c @@ -617,7 +617,7 @@ initialize_def (symbol_t *sym, expr_t *init, defspace_t *space, internal_error (0, "initializier not a value"); return; } - if (init->e.value->lltype == ev_pointer + if (init->e.value->lltype == ev_ptr || init->e.value->lltype == ev_field) { // FIXME offset pointers D_INT (sym->s.def) = init->e.value->v.pointer.val; diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index d1cbfee26..19081fd48 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -547,7 +547,7 @@ print_value (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) e->e.value->v.quaternion_val[2], e->e.value->v.quaternion_val[3]); break; - case ev_pointer: + case ev_ptr: type = e->e.value->v.pointer.type; dstring_clearstr(type_str); if (type) { diff --git a/tools/qfcc/source/dot_type.c b/tools/qfcc/source/dot_type.c index fa77bbf3d..5f743dae7 100644 --- a/tools/qfcc/source/dot_type.c +++ b/tools/qfcc/source/dot_type.c @@ -61,7 +61,7 @@ print_pointer (dstring_t *dstr, type_t *t, int level, int id) dot_print_type (dstr, aux, level, id); dasprintf (dstr, "%*st_%p -> \"t_%p\";\n", indent, "", t, aux); dasprintf (dstr, "%*st_%p [label=\"%c\"];\n", indent, "", t, - t->type == ev_pointer ? '*' : '.'); + t->type == ev_ptr ? '*' : '.'); } static void @@ -118,7 +118,7 @@ print_function (dstring_t *dstr, type_t *t, int level, int id) static void print_basic (dstring_t *dstr, type_t *t, int level, int id) { - if (t->type == ev_pointer || t->type == ev_field) { + if (t->type == ev_ptr || t->type == ev_field) { print_pointer (dstr, t, level, id); } else if (t->type == ev_func) { print_function (dstr, t, level, id); diff --git a/tools/qfcc/source/dump_globals.c b/tools/qfcc/source/dump_globals.c index e55c10104..5bff7e2a0 100644 --- a/tools/qfcc/source/dump_globals.c +++ b/tools/qfcc/source/dump_globals.c @@ -131,7 +131,7 @@ dump_def (progs_t *pr, pr_def_t *def, int indent) } } break; - case ev_pointer: + case ev_ptr: comment = va (0, " %x", G_INT (pr, offset)); break; case ev_quat: @@ -559,7 +559,7 @@ dump_qfo_types (qfo_t *qfo, int base_address) count = ~count; //ones complement for (i = 0; i < count; i++) printf (" %x", type->func.param_types[i]); - } else if (type->type == ev_pointer + } else if (type->type == ev_ptr || type->type == ev_field) { printf (" %4x", type->fldptr.aux_type); } diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 47daa1348..61e42c552 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -222,6 +222,7 @@ get_type (expr_t *e) case ex_memset: return e->e.memset.type; case ex_error: + return 0; case ex_return: internal_error (e, "unexpected expression type"); case ex_label: @@ -1263,7 +1264,7 @@ expr_integral (expr_t *e) int is_pointer_val (expr_t *e) { - if (e->type == ex_value && e->e.value->lltype == ev_pointer) { + if (e->type == ex_value && e->e.value->lltype == ev_ptr) { return 1; } return 0; @@ -1432,7 +1433,7 @@ field_expr (expr_t *e1, expr_t *e2) return e; } } - } else if (t1->type == ev_pointer) { + } else if (t1->type == ev_ptr) { if (is_struct (t1->t.fldptr.type)) { symbol_t *field; @@ -1695,7 +1696,7 @@ unary_expr (int op, expr_t *e) case ev_entity: case ev_field: case ev_func: - case ev_pointer: + case ev_ptr: internal_error (e, "type check failed!"); case ev_double: new = new_double_expr (-expr_double (e)); @@ -1797,7 +1798,7 @@ unary_expr (int op, expr_t *e) case ev_entity: case ev_field: case ev_func: - case ev_pointer: + case ev_ptr: internal_error (e, 0); case ev_string: s = expr_string (e); @@ -1875,7 +1876,7 @@ unary_expr (int op, expr_t *e) case ev_entity: case ev_field: case ev_func: - case ev_pointer: + case ev_ptr: case ev_vector: case ev_double: return error (e, "invalid type for unary ~"); @@ -1956,7 +1957,7 @@ bitnot_expr: } break; case '.': - if (extract_type (e) != ev_pointer) + if (extract_type (e) != ev_ptr) return error (e, "invalid type for unary ."); e = new_unary_expr ('.', e); e->e.expr.type = get_type (e->e.expr.e1)->t.fldptr.type; @@ -2392,7 +2393,7 @@ array_expr (expr_t *array, expr_t *index) if (index->type == ex_error) return index; - if (array_type->type != ev_pointer && !is_array (array_type)) + if (array_type->type != ev_ptr && !is_array (array_type)) return error (array, "not an array"); if (!is_integral (index_type)) return error (index, "invalid array index type"); @@ -2436,7 +2437,7 @@ pointer_expr (expr_t *pointer) if (pointer->type == ex_error) return pointer; - if (pointer_type->type != ev_pointer) + if (pointer_type->type != ev_ptr) return error (pointer, "not a pointer"); return array_expr (pointer, new_int_expr (0)); } @@ -2889,7 +2890,9 @@ sizeof_expr (expr_t *expr, struct type_s *type) internal_error (0, 0); if (!type) type = get_type (expr); - expr = new_int_expr (type_size (type)); + if (type) { + expr = new_int_expr (type_size (type)); + } return expr; } diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index 885f87ef1..7610b4542 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -533,7 +533,7 @@ static expr_type_t *string_x[ev_type_count] = { 0, // ev_entity 0, // ev_field 0, // ev_func - 0, // ev_pointer + 0, // ev_ptr 0, // ev_quat 0, // ev_int 0, // ev_uint @@ -549,7 +549,7 @@ static expr_type_t *float_x[ev_type_count] = { 0, // ev_entity 0, // ev_field 0, // ev_func - 0, // ev_pointer + 0, // ev_ptr float_quat, float_int, float_uint, @@ -565,7 +565,7 @@ static expr_type_t *vector_x[ev_type_count] = { 0, // ev_entity 0, // ev_field 0, // ev_func - 0, // ev_pointer + 0, // ev_ptr 0, // ev_quaternion vector_int, vector_uint, @@ -581,7 +581,7 @@ static expr_type_t *entity_x[ev_type_count] = { entity_entity, // ev_entity 0, // ev_field 0, // ev_func - 0, // ev_pointer + 0, // ev_ptr 0, // ev_quaternion 0, // ev_int 0, // ev_uint @@ -597,7 +597,7 @@ static expr_type_t *field_x[ev_type_count] = { 0, // ev_entity field_field, // ev_field 0, // ev_func - 0, // ev_pointer + 0, // ev_ptr 0, // ev_quaternion 0, // ev_int 0, // ev_uint @@ -613,7 +613,7 @@ static expr_type_t *func_x[ev_type_count] = { 0, // ev_entity 0, // ev_field func_func, // ev_func - 0, // ev_pointer + 0, // ev_ptr 0, // ev_quaternion 0, // ev_int 0, // ev_uint @@ -645,7 +645,7 @@ static expr_type_t *quat_x[ev_type_count] = { 0, // ev_entity 0, // ev_field 0, // ev_func - 0, // ev_pointer + 0, // ev_ptr quat_quat, quat_int, quat_uint, @@ -709,7 +709,7 @@ static expr_type_t *double_x[ev_type_count] = { 0, // ev_entity 0, // ev_field 0, // ev_func - 0, // ev_pointer + 0, // ev_ptr double_quat, double_int, double_uint, diff --git a/tools/qfcc/source/expr_bool.c b/tools/qfcc/source/expr_bool.c index df8e25180..52b4de683 100644 --- a/tools/qfcc/source/expr_bool.c +++ b/tools/qfcc/source/expr_bool.c @@ -132,7 +132,7 @@ test_expr (expr_t *e) return new_alias_expr (type_default, e); case ev_func: return new_alias_expr (type_default, e); - case ev_pointer: + case ev_ptr: return new_alias_expr (type_default, e); case ev_quat: new = new_quaternion_expr (zero); diff --git a/tools/qfcc/source/flow.c b/tools/qfcc/source/flow.c index 37d0c1814..8edc44ad1 100644 --- a/tools/qfcc/source/flow.c +++ b/tools/qfcc/source/flow.c @@ -1127,7 +1127,7 @@ flow_analyze_pointer_operand (operand_t *ptrop, set_t *def) { operand_t *op = 0; - if (ptrop->op_type == op_value && ptrop->value->lltype == ev_pointer) { + if (ptrop->op_type == op_value && ptrop->value->lltype == ev_ptr) { ex_pointer_t *ptr = &ptrop->value->v.pointer; if (ptrop->value->v.pointer.def) { def_t *alias; diff --git a/tools/qfcc/source/obj_type.c b/tools/qfcc/source/obj_type.c index d806e6c9b..8d1f5cacf 100644 --- a/tools/qfcc/source/obj_type.c +++ b/tools/qfcc/source/obj_type.c @@ -149,7 +149,7 @@ qfo_encode_basic (type_t *type, defspace_t *space) if (type->type == ev_func) return qfo_encode_func (type, space); - else if (type->type == ev_pointer || type->type == ev_field) + else if (type->type == ev_ptr || type->type == ev_field) return qfo_encode_fldptr (type, space); def = qfo_new_encoding (type, sizeof (enc->type), space); diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 0d52f7c4e..a0aa7997f 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -140,7 +140,7 @@ operand_string (operand_t *op) op->value->v.quaternion_val[1], op->value->v.quaternion_val[2], op->value->v.quaternion_val[3]); - case ev_pointer: + case ev_ptr: if (op->value->v.pointer.def) { return va (0, "ptr %s+%d", op->value->v.pointer.def->name, @@ -227,7 +227,7 @@ _print_operand (operand_t *op) printf (" %g", op->value->v.quaternion_val[2]); printf (" %g'", op->value->v.quaternion_val[3]); break; - case ev_pointer: + case ev_ptr: printf ("(%s)[%d]", pr_type_name[op->value->v.pointer.type->type], op->value->v.pointer.val); @@ -761,7 +761,7 @@ operand_address (operand_t *reference, expr_t *e) static __attribute__((pure)) int is_const_ptr (expr_t *e) { - if ((e->type != ex_value || e->e.value->lltype != ev_pointer) + if ((e->type != ex_value || e->e.value->lltype != ev_ptr) || !(POINTER_VAL (e->e.value->v.pointer) >= 0 && POINTER_VAL (e->e.value->v.pointer) < 65536)) { return 0; @@ -1170,7 +1170,7 @@ expr_deref (sblock_t *sblock, expr_t *deref, operand_t **op) s->opc = *op; sblock_add_statement (sblock, s); } - } else if (e->type == ex_value && e->e.value->lltype == ev_pointer) { + } else if (e->type == ex_value && e->e.value->lltype == ev_ptr) { ex_pointer_t *ptr = &e->e.value->v.pointer; *op = def_operand (alias_def (ptr->def, ptr->type, ptr->val), ptr->type, e); diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index 81583de9c..de6709c9d 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -72,7 +72,7 @@ type_t type_field = {ev_field, "field", 1, ty_basic, {{&type_void}} }; // type_function is a void() function used for state defs type_t type_function = { ev_func, "function", 1, ty_basic, {{&type_void}} }; -type_t type_pointer = { ev_pointer, "pointer", 1, ty_basic, +type_t type_pointer = { ev_ptr, "pointer", 1, ty_basic, {{&type_void}} }; type_t type_quaternion = { ev_quat, "quaternion", 4 }; type_t type_int = { ev_int, "int", 1 }; @@ -90,7 +90,7 @@ type_t type_zero = { ev_invalid, 0, 0, ty_struct }; type_t type_type_encodings = { ev_invalid, "@type_encodings", 0, ty_struct }; type_t type_xdef = { ev_invalid, "@xdef", 0, ty_struct }; -type_t type_xdef_pointer = { ev_pointer, 0, 1, ty_basic, {{&type_xdef}} }; +type_t type_xdef_pointer = { ev_ptr, 0, 1, ty_basic, {{&type_xdef}} }; type_t type_xdefs = { ev_invalid, "@xdefs", 0, ty_struct }; type_t type_floatfield = { ev_field, ".float", 1, ty_basic, @@ -194,7 +194,7 @@ free_type (type_t *type) case ev_double: break; case ev_field: - case ev_pointer: + case ev_ptr: free_type (type->t.fldptr.type); break; case ev_func: @@ -236,7 +236,7 @@ copy_chain (type_t *type, type_t *append) case ev_double: internal_error (0, "copy basic type"); case ev_field: - case ev_pointer: + case ev_ptr: n = &(*n)->t.fldptr.type; type = type->t.fldptr.type; break; @@ -289,7 +289,7 @@ append_type (type_t *type, type_t *new) case ev_double: internal_error (0, "append to basic type"); case ev_field: - case ev_pointer: + case ev_ptr: t = &(*t)->t.fldptr.type; type->alignment = 1; break; @@ -335,7 +335,7 @@ types_same (type_t *a, type_t *b) case ty_basic: switch (a->type) { case ev_field: - case ev_pointer: + case ev_ptr: if (a->t.fldptr.type != b->t.fldptr.type) return 0; case ev_func: @@ -401,7 +401,7 @@ find_type (type_t *type) case ty_basic: switch (type->type) { case ev_field: - case ev_pointer: + case ev_ptr: type->t.fldptr.type = find_type (type->t.fldptr.type); break; case ev_func: @@ -475,7 +475,7 @@ pointer_type (type_t *aux) memset (&_new, 0, sizeof (_new)); else new = new_type (); - new->type = ev_pointer; + new->type = ev_ptr; new->alignment = 1; if (aux) { new = find_type (append_type (new, aux)); @@ -639,7 +639,7 @@ print_type_str (dstring_t *str, const type_t *type) dasprintf (str, ")"); } return; - case ev_pointer: + case ev_ptr: if (is_id (type)) { dasprintf (str, "id"); if (type->t.fldptr.type->protos) @@ -802,7 +802,7 @@ encode_type (dstring_t *encoding, const type_t *type) encode_type (encoding, type->t.func.type); dasprintf (encoding, "%s)", encode_params (type)); return; - case ev_pointer: + case ev_ptr: if (is_id(type)) { dasprintf (encoding, "@"); return; @@ -962,7 +962,7 @@ int is_pointer (const type_t *type) { type = unalias_type (type); - if (type->type == ev_pointer) + if (type->type == ev_ptr) return 1; return 0; } diff --git a/tools/qfcc/source/value.c b/tools/qfcc/source/value.c index 786a3d2fb..73b3b47ab 100644 --- a/tools/qfcc/source/value.c +++ b/tools/qfcc/source/value.c @@ -262,7 +262,7 @@ new_nil_val (type_t *type) if (val.lltype == ev_void) { val.lltype = type_nil->type; } - if (val.lltype == ev_pointer || val.lltype == ev_field ) + if (val.lltype == ev_ptr || val.lltype == ev_field ) val.v.pointer.type = type->t.fldptr.type; if (val.lltype == ev_func) val.v.func_val.type = type; @@ -507,7 +507,7 @@ emit_value (ex_value_t *value, def_t *def) tab = func_imm_defs; type = &type_function; break; - case ev_pointer: + case ev_ptr: tab = pointer_imm_defs; type = &type_pointer; break; @@ -604,7 +604,7 @@ emit_value (ex_value_t *value, def_t *def) if (val.v.pointer.def) reloc_def_field_ofs (val.v.pointer.def, cn); break; - case ev_pointer: + case ev_ptr: if (val.v.pointer.def) { EMIT_DEF_OFS (pr.near_data, D_INT (cn), val.v.pointer.def); diff --git a/tools/qfcc/test/typedef.r b/tools/qfcc/test/typedef.r index 3755f63eb..61df8f9b6 100644 --- a/tools/qfcc/test/typedef.r +++ b/tools/qfcc/test/typedef.r @@ -24,7 +24,7 @@ next_type (qfot_type_t *type) int check_alias (string name, qfot_type_t *alias) { - if (alias.meta != ty_basic || alias.type != ev_pointer + if (alias.meta != ty_basic || alias.type != ev_ptr || alias.fldptr.aux_type.meta != ty_basic || alias.fldptr.aux_type.type != ev_int) { printf ("%s is not a *int alias\n", name); From e9e54d08c0383f3fa4e0d78e38c442bb10be9ec2 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 15:32:43 +0900 Subject: [PATCH 140/360] [gamecode] Rename func_t to pr_func_t Even more consistency. --- doc/progs/vm-exec.c | 2 +- include/QF/progs.h | 16 ++++++------ include/QF/progs/pr_comp.h | 4 +-- include/QF/progs/pr_obj.h | 2 +- include/QF/ruamoko.h | 4 +-- libs/console/bi_inputline.c | 2 +- libs/console/menu.c | 34 +++++++++++++------------- libs/gamecode/pr_debug.c | 20 +++++++-------- libs/gamecode/pr_exec.c | 6 ++--- libs/gamecode/test/main.c | 2 +- libs/gib/bi_gib.c | 6 ++--- libs/ruamoko/rua_cmd.c | 4 +-- libs/ruamoko/rua_hash.c | 8 +++--- libs/ruamoko/rua_input.c | 22 ++++++++--------- libs/ruamoko/rua_obj.c | 30 +++++++++++------------ libs/ruamoko/rua_stdlib.c | 8 +++--- nq/include/sv_progs.h | 28 ++++++++++----------- nq/source/sv_progs.c | 4 +-- qw/include/sv_progs.h | 42 ++++++++++++++++---------------- qw/source/sv_pr_cpqw.c | 6 ++--- qw/source/sv_pr_qwe.c | 12 ++++----- qw/source/sv_progs.c | 4 +-- qw/source/sv_user.c | 2 +- ruamoko/qwaq/builtins/debug.c | 6 ++--- ruamoko/qwaq/builtins/graphics.c | 2 +- ruamoko/qwaq/qwaq.h | 2 +- tools/qfcc/include/obj_file.h | 2 +- tools/qfcc/source/dump_globals.c | 2 +- tools/qfcc/test/test-harness.c | 2 +- 29 files changed, 142 insertions(+), 142 deletions(-) diff --git a/doc/progs/vm-exec.c b/doc/progs/vm-exec.c index 1f9ae4b8e..b250848cd 100644 --- a/doc/progs/vm-exec.c +++ b/doc/progs/vm-exec.c @@ -5,7 +5,7 @@ call_progs_main (progs_t *pr, int argc, const char **argv) { int i; dfunction_t *dfunc; - func_t progs_main = 0; + pr_func_t progs_main = 0; string_t *pr_argv; if ((dfunc = PR_FindFunction (pr, "main"))) { diff --git a/include/QF/progs.h b/include/QF/progs.h index f9ae57c63..d2d32cf51 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -167,7 +167,7 @@ void PR_PopFrame (progs_t *pr); \param pr pointer to ::progs_t VM struct \param fnum number of the function to call */ -void PR_ExecuteProgram (progs_t *pr, func_t fnum); +void PR_ExecuteProgram (progs_t *pr, pr_func_t fnum); /** Setup to call a function. If \p fnum is a builtin rather than a progs function, then the function is called immediately. When called from a @@ -180,7 +180,7 @@ void PR_ExecuteProgram (progs_t *pr, func_t fnum); \return true if \p fnum was a progs function, false if \p fnum was a builtin */ -int PR_CallFunction (progs_t *pr, func_t fnum, pr_type_t *return_ptr); +int PR_CallFunction (progs_t *pr, pr_func_t fnum, pr_type_t *return_ptr); ///@} @@ -482,7 +482,7 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ \c void() \param p pointer to ::progs_t VM struct \param o offset into global data space - \return func_t lvalue + \return pr_func_t lvalue \hideinitializer */ @@ -698,7 +698,7 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ \c void() \param p pointer to ::progs_t VM struct \param n parameter number (0-7) - \return func_t lvalue + \return pr_func_t lvalue \hideinitializer */ @@ -902,12 +902,12 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ */ #define R_STRING(p) R_var (p, string) -/** Access the VM function return value as a ::func_t (a VM function reference) +/** Access the VM function return value as a ::pr_func_t (a VM function reference) \par QC type: \c void() \param p pointer to ::progs_t VM struct - \return ::func_t lvalue + \return ::pr_func_t lvalue \hideinitializer */ @@ -1103,7 +1103,7 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ \c void() \param e pointer to the entity \param o field offset into entity data space - \return func_t lvalue + \return pr_func_t lvalue \hideinitializer */ @@ -1911,7 +1911,7 @@ struct progs_s { pr_type_t *pr_edict_area; int pr_edict_size; ///< # of pr_type_t slots pr_uint_t pr_edict_area_size; ///< for bounds checking, starts at 0 - func_t edict_parse; + pr_func_t edict_parse; ///@} /// \name execution state diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 9dbaea8db..fa7348161 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -29,9 +29,9 @@ typedef int16_t pr_short_t; typedef uint16_t pr_ushort_t; typedef int32_t pr_int_t; typedef uint32_t pr_uint_t; +typedef uint32_t pr_func_t; typedef int64_t pr_long_t; typedef uint64_t pr_ulong_t; -typedef pr_uint_t func_t; typedef pr_int_t pr_string_t; typedef pr_uint_t pr_ptr_t; @@ -520,7 +520,7 @@ typedef struct dfunction_s { typedef union pr_type_u { float float_var; pr_string_t string_var; - func_t func_var; + pr_func_t func_var; pr_uint_t entity_var; float vector_var; // really [3], but this structure must be 32 bits float quat_var; // really [4], but this structure must be 32 bits diff --git a/include/QF/progs/pr_obj.h b/include/QF/progs/pr_obj.h index 00f493469..2841f6064 100644 --- a/include/QF/progs/pr_obj.h +++ b/include/QF/progs/pr_obj.h @@ -129,7 +129,7 @@ typedef struct pr_method_list_s { struct pr_method_s { pr_ptr_t method_name; // pr_sel_t pr_string_t method_types; - func_t method_imp; // typedef id (id, SEL, ...) IMP + pr_func_t method_imp; // typedef id (id, SEL, ...) IMP } method_list[1]; } pr_method_list_t; typedef struct pr_method_s pr_method_t; diff --git a/include/QF/ruamoko.h b/include/QF/ruamoko.h index 8ee071632..71c2fe6ee 100644 --- a/include/QF/ruamoko.h +++ b/include/QF/ruamoko.h @@ -38,8 +38,8 @@ struct cbuf_s; void RUA_Init (struct progs_s *pr, int secure); void RUA_Cbuf_SetCbuf (struct progs_s *pr, struct cbuf_s *cbuf); -func_t RUA_Obj_msg_lookup (struct progs_s *pr, pr_ptr_t _self, - pr_ptr_t __cmd); +pr_func_t RUA_Obj_msg_lookup (struct progs_s *pr, pr_ptr_t _self, + pr_ptr_t __cmd); void RUA_Game_Init (struct progs_s *pr, int secure); diff --git a/libs/console/bi_inputline.c b/libs/console/bi_inputline.c index 1c63a69a7..a2de6285c 100644 --- a/libs/console/bi_inputline.c +++ b/libs/console/bi_inputline.c @@ -49,7 +49,7 @@ typedef struct il_data_s { struct il_data_s **prev; inputline_t *line; progs_t *pr; - func_t enter; // enter key callback + pr_func_t enter; // enter key callback pr_ptr_t data[2]; // allow two data params for the callback int method; // true if method rather than function } il_data_t; diff --git a/libs/console/menu.c b/libs/console/menu.c index a98c2d71a..80bcc772e 100644 --- a/libs/console/menu.c +++ b/libs/console/menu.c @@ -67,12 +67,12 @@ typedef struct menu_item_s { int max_items; int cur_item; int x, y; - func_t func; - func_t cursor; - func_t keyevent; - func_t draw; - func_t enter_hook; - func_t leave_hook; + pr_func_t func; + pr_func_t cursor; + pr_func_t keyevent; + pr_func_t draw; + pr_func_t enter_hook; + pr_func_t leave_hook; unsigned fadescreen:1; unsigned allkeys:1; const char *text; @@ -85,16 +85,16 @@ static progs_t menu_pr_state; static menu_item_t *menu; //static keydest_t menu_keydest; static hashtab_t *menu_hash; -static func_t menu_init; -static func_t menu_quit; -static func_t menu_draw_hud; -static func_t menu_pre; -static func_t menu_post; +static pr_func_t menu_init; +static pr_func_t menu_quit; +static pr_func_t menu_draw_hud; +static pr_func_t menu_pre; +static pr_func_t menu_post; static const char *top_menu; typedef struct menu_func_s { const char *name; - func_t *func; + pr_func_t *func; } menu_func_t; static menu_func_t menu_functions[] = { @@ -129,7 +129,7 @@ menu_resolve_globals (progs_t *pr) sym = menu_functions[i].name; if (!(f = PR_FindFunction (pr, sym))) goto error; - *menu_functions[i].func = (func_t) (f - menu_pr_state.pr_functions); + *menu_functions[i].func = (pr_func_t) (f - menu_pr_state.pr_functions); } if (!(def = PR_FindGlobal (pr, sym = "time"))) @@ -315,7 +315,7 @@ bi_Menu_Item (progs_t *pr) int x = P_INT (pr, 0); int y = P_INT (pr, 1); const char *text = P_GSTRING (pr, 2); - func_t func = P_FUNCTION (pr, 3); + pr_func_t func = P_FUNCTION (pr, 3); int allkeys = P_INT (pr, 4); menu_item_t *mi = calloc (sizeof (menu_item_t), 1); @@ -331,7 +331,7 @@ bi_Menu_Item (progs_t *pr) static void bi_Menu_Cursor (progs_t *pr) { - func_t func = P_FUNCTION (pr, 0); + pr_func_t func = P_FUNCTION (pr, 0); menu->cursor = func; } @@ -339,7 +339,7 @@ bi_Menu_Cursor (progs_t *pr) static void bi_Menu_KeyEvent (progs_t *pr) { - func_t func = P_FUNCTION (pr, 0); + pr_func_t func = P_FUNCTION (pr, 0); menu->keyevent = func; } @@ -385,7 +385,7 @@ bi_Menu_SelectMenu (progs_t *pr) static void bi_Menu_SetQuit (progs_t *pr) { - func_t func = P_FUNCTION (pr, 0); + pr_func_t func = P_FUNCTION (pr, 0); menu_quit = func; } diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 16d584e88..f06fdf39f 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -95,7 +95,7 @@ typedef struct prdeb_resources_s { pr_debug_header_t *debug; pr_auxfunction_t *auxfunctions; pr_auxfunction_t **auxfunction_map; - func_t *sorted_functions; + pr_func_t *sorted_functions; pr_lineno_t *linenos; pr_def_t *local_defs; pr_def_t *type_encodings_def; @@ -502,8 +502,8 @@ func_compare_sort (const void *_fa, const void *_fb, void *_res) { prdeb_resources_t *res = _res; progs_t *pr = res->pr; - func_t fa = *(const func_t *)_fa; - func_t fb = *(const func_t *)_fb; + pr_func_t fa = *(const pr_func_t *)_fa; + pr_func_t fb = *(const pr_func_t *)_fb; const char *fa_file = PR_GetString (pr, pr->pr_functions[fa].file); const char *fb_file = PR_GetString (pr, pr->pr_functions[fb].file); int cmp = strcmp (fa_file, fb_file); @@ -523,7 +523,7 @@ func_compare_search (const void *_key, const void *_f, void *_res) prdeb_resources_t *res = _res; progs_t *pr = res->pr; const func_key_t *key = _key; - func_t f = *(const func_t *)_f; + pr_func_t f = *(const pr_func_t *)_f; const char *f_file = PR_GetString (pr, pr->pr_functions[f].file); int cmp = strcmp (key->file, f_file); if (cmp) { @@ -548,7 +548,7 @@ PR_DebugSetSym (progs_t *pr, pr_debug_header_t *debug) size_t size; size = pr->progs->numfunctions * sizeof (pr_auxfunction_t *); res->auxfunction_map = pr->allocate_progs_mem (pr, size); - size = pr->progs->numfunctions * sizeof (func_t); + size = pr->progs->numfunctions * sizeof (pr_func_t); res->sorted_functions = pr->allocate_progs_mem (pr, size); for (pr_uint_t i = 0; i < pr->progs->numfunctions; i++) { @@ -572,8 +572,8 @@ PR_DebugSetSym (progs_t *pr, pr_debug_header_t *debug) res->auxfunction_map[res->auxfunctions[i].function] = &res->auxfunctions[i]; } - qsort_r (res->sorted_functions, pr->progs->numfunctions, sizeof (func_t), - func_compare_sort, res); + qsort_r (res->sorted_functions, pr->progs->numfunctions, + sizeof (pr_func_t), func_compare_sort, res); for (pr_uint_t i = 0; i < debug->num_locals; i++) { if (type_encodings) { @@ -837,8 +837,8 @@ PR_FindSourceLineAddr (progs_t *pr, const char *file, pr_uint_t line) { prdeb_resources_t *res = pr->pr_debug_resources; func_key_t key = { file, line }; - func_t *f = fbsearch_r (&key, res->sorted_functions, - pr->progs->numfunctions, sizeof (func_t), + pr_func_t *f = fbsearch_r (&key, res->sorted_functions, + pr->progs->numfunctions, sizeof (pr_func_t), func_compare_search, res); if (!f) { return 0; @@ -1591,7 +1591,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) unsigned parm_ind = 0; pr_uint_t opval; qfot_type_t *optype = &res->void_type; - func_t func; + pr_func_t func; if (mode == 'P') { opchar = fmt[3]; diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index d0f94d8fb..3b5b8c6f3 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -421,7 +421,7 @@ error_handler (void *data) } VISIBLE int -PR_CallFunction (progs_t *pr, func_t fnum, pr_type_t *return_ptr) +PR_CallFunction (progs_t *pr, pr_func_t fnum, pr_type_t *return_ptr) { bfunction_t *f; @@ -2766,7 +2766,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) pr_type_t *stk; pr_type_t *mm; - func_t function; + pr_func_t function; pr_opcode_e st_op = st->op & OP_MASK; switch (st_op) { // 0 0000 @@ -3461,7 +3461,7 @@ exit_program: The interpretation main loop */ VISIBLE void -PR_ExecuteProgram (progs_t *pr, func_t fnum) +PR_ExecuteProgram (progs_t *pr, pr_func_t fnum) { Sys_PushSignalHook (signal_hook, pr); Sys_PushErrorHandler (error_handler, pr); diff --git a/libs/gamecode/test/main.c b/libs/gamecode/test/main.c index c9c34be53..9f988fd50 100644 --- a/libs/gamecode/test/main.c +++ b/libs/gamecode/test/main.c @@ -37,7 +37,7 @@ test_debug_handler (prdebug_t event, void *param, void *data) longjmp (jump_buffer, 1); case prd_subenter: if (verbose > 0) { - printf ("debug: subenter %d\n", *(func_t *) param); + printf ("debug: subenter %d\n", *(pr_func_t *) param); } case prd_subexit: break; diff --git a/libs/gib/bi_gib.c b/libs/gib/bi_gib.c index 726e18d8b..f2f9bc671 100644 --- a/libs/gib/bi_gib.c +++ b/libs/gib/bi_gib.c @@ -48,8 +48,8 @@ typedef struct bi_gib_builtin_s { struct bi_gib_builtin_s *next; gib_builtin_t *builtin; - progs_t *pr; - func_t func; + progs_t *pr; + pr_func_t func; } bi_gib_builtin_t; typedef struct bi_gib_resources_s { @@ -117,7 +117,7 @@ bi_GIB_Builtin_Add (progs_t *pr) bi_gib_resources_t *res = PR_Resources_Find (pr, "GIB"); bi_gib_builtin_t *builtin; const char *name = P_GSTRING (pr, 0); - func_t func = P_FUNCTION (pr, 1); + pr_func_t func = P_FUNCTION (pr, 1); if (GIB_Builtin_Exists (name)) { R_INT (pr) = 0; diff --git a/libs/ruamoko/rua_cmd.c b/libs/ruamoko/rua_cmd.c index 8efcfb2a5..44006b815 100644 --- a/libs/ruamoko/rua_cmd.c +++ b/libs/ruamoko/rua_cmd.c @@ -50,7 +50,7 @@ typedef struct bi_cmd_s { struct bi_cmd_s *next; char *name; progs_t *pr; - func_t func; + pr_func_t func; } bi_cmd_t; typedef struct { @@ -90,7 +90,7 @@ bi_Cmd_AddCommand (progs_t *pr) cmd_resources_t *res = PR_Resources_Find (pr, "Cmd"); bi_cmd_t *cmd = malloc (sizeof (bi_cmd_t)); char *name = strdup (P_GSTRING (pr, 0)); - func_t func = P_FUNCTION (pr, 1); + pr_func_t func = P_FUNCTION (pr, 1); if (!cmd || !name || !Cmd_AddCommand (name, bi_cmd_f, "CSQC command")) { if (name) diff --git a/libs/ruamoko/rua_hash.c b/libs/ruamoko/rua_hash.c index 27a40d3d5..3e9336398 100644 --- a/libs/ruamoko/rua_hash.c +++ b/libs/ruamoko/rua_hash.c @@ -49,10 +49,10 @@ typedef struct bi_hashtab_s { struct bi_hashtab_s **prev; progs_t *pr; hashtab_t *tab; - func_t gk; - func_t gh; - func_t cmp; - func_t f; + pr_func_t gk; + pr_func_t gh; + pr_func_t cmp; + pr_func_t f; pr_ptr_t ud; } bi_hashtab_t; diff --git a/libs/ruamoko/rua_input.c b/libs/ruamoko/rua_input.c index 8fefa5fa9..b838b3086 100644 --- a/libs/ruamoko/rua_input.c +++ b/libs/ruamoko/rua_input.c @@ -46,7 +46,7 @@ typedef struct rua_in_cookie_s { size_t users; progs_t *pr; - func_t func; + pr_func_t func; pr_ptr_t data; } rua_in_cookie_t; @@ -193,7 +193,7 @@ bi_IN_GetButtonInfo (progs_t *pr) } static rua_in_cookie_t * -make_cookie (progs_t *pr, func_t func, pr_ptr_t data) +make_cookie (progs_t *pr, pr_func_t func, pr_ptr_t data) { input_resources_t *res = PR_Resources_Find (pr, "input"); rua_in_cookie_t search = { @@ -212,7 +212,7 @@ make_cookie (progs_t *pr, func_t func, pr_ptr_t data) } static rua_in_cookie_t * -find_cookie (progs_t *pr, func_t func, pr_ptr_t data) +find_cookie (progs_t *pr, pr_func_t func, pr_ptr_t data) { input_resources_t *res = PR_Resources_Find (pr, "input"); rua_in_cookie_t search = { @@ -236,8 +236,8 @@ static void rua_add_axis_listener (progs_t *pr, axis_listener_t listener) { in_axis_t *axis = &P_STRUCT (pr, in_axis_t, 0); - func_t func = P_FUNCTION (pr, 1); - func_t data = P_POINTER (pr, 2); + pr_func_t func = P_FUNCTION (pr, 1); + pr_func_t data = P_POINTER (pr, 2); rua_in_cookie_t *cookie = make_cookie (pr, func, data); IN_AxisAddListener (axis, listener, cookie); } @@ -246,8 +246,8 @@ static void rua_remove_axis_listener (progs_t *pr, axis_listener_t listener) { in_axis_t *axis = &P_STRUCT (pr, in_axis_t, 0); - func_t func = P_FUNCTION (pr, 1); - func_t data = P_POINTER (pr, 2); + pr_func_t func = P_FUNCTION (pr, 1); + pr_func_t data = P_POINTER (pr, 2); rua_in_cookie_t *cookie = find_cookie (pr, func, data); if (cookie) { IN_AxisRemoveListener (axis, listener, cookie); @@ -259,8 +259,8 @@ static void rua_add_button_listener (progs_t *pr, button_listener_t listener) { in_button_t *button = &P_STRUCT (pr, in_button_t, 0); - func_t func = P_FUNCTION (pr, 1); - func_t data = P_POINTER (pr, 2); + pr_func_t func = P_FUNCTION (pr, 1); + pr_func_t data = P_POINTER (pr, 2); rua_in_cookie_t *cookie = make_cookie (pr, func, data); IN_ButtonAddListener (button, listener, cookie); } @@ -269,8 +269,8 @@ static void rua_remove_button_listener (progs_t *pr, button_listener_t listener) { in_button_t *button = &P_STRUCT (pr, in_button_t, 0); - func_t func = P_FUNCTION (pr, 1); - func_t data = P_POINTER (pr, 2); + pr_func_t func = P_FUNCTION (pr, 1); + pr_func_t data = P_POINTER (pr, 2); rua_in_cookie_t *cookie = find_cookie (pr, func, data); if (cookie) { IN_ButtonRemoveListener (button, listener, cookie); diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index 66994f65c..092562d50 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -68,7 +68,7 @@ typedef struct dtable_s { struct dtable_s *next; struct dtable_s **prev; size_t size; - func_t *imp; + pr_func_t *imp; } dtable_t; typedef struct probj_resources_s { @@ -79,7 +79,7 @@ typedef struct probj_resources_s { pr_string_t *selector_names; PR_RESMAP (dtable_t) dtables; dtable_t *dtable_list; - func_t obj_forward; + pr_func_t obj_forward; pr_sel_t *forward_selector; dstring_t *msg; hashtab_t *selector_hash; @@ -936,7 +936,7 @@ obj_install_dispatch_table_for_class (probj_t *probj, pr_class_t *class) dtable = dtable_new (probj); class->dtable = dtable_index (probj, dtable); dtable->size = probj->selector_index + 1; - dtable->imp = calloc (dtable->size, sizeof (func_t)); + dtable->imp = calloc (dtable->size, sizeof (pr_func_t)); if (super) { dtable_t *super_dtable = get_dtable (probj, __FUNCTION__, super->dtable); @@ -957,10 +957,10 @@ obj_check_dtable_installed (probj_t *probj, pr_class_t *class) return get_dtable (probj, __FUNCTION__, class->dtable); } -static func_t +static pr_func_t get_imp (probj_t *probj, pr_class_t *class, pr_sel_t *sel) { - func_t imp = 0; + pr_func_t imp = 0; if (class->dtable) { dtable_t *dtable = get_dtable (probj, __FUNCTION__, class->dtable); @@ -985,7 +985,7 @@ obj_reponds_to (probj_t *probj, pr_id_t *obj, pr_sel_t *sel) progs_t *pr = probj->pr; pr_class_t *class; dtable_t *dtable; - func_t imp = 0; + pr_func_t imp = 0; class = &G_STRUCT (pr, pr_class_t, obj->class_pointer); dtable = obj_check_dtable_installed (probj, class); @@ -996,7 +996,7 @@ obj_reponds_to (probj_t *probj, pr_id_t *obj, pr_sel_t *sel) return imp != 0; } -static func_t +static pr_func_t obj_msg_lookup (probj_t *probj, pr_id_t *receiver, pr_sel_t *op) { progs_t *pr = probj->pr; @@ -1015,7 +1015,7 @@ obj_msg_lookup (probj_t *probj, pr_id_t *receiver, pr_sel_t *op) return get_imp (probj, class, op); } -static func_t +static pr_func_t obj_msg_lookup_super (probj_t *probj, pr_super_t *super, pr_sel_t *op) { progs_t *pr = probj->pr; @@ -1260,7 +1260,7 @@ rua___obj_forward (progs_t *pr) pr_sel_t *fwd_sel = probj->forward_selector; pr_sel_t *err_sel; pr_class_t *class =&G_STRUCT (pr, pr_class_t, obj->class_pointer); - func_t imp; + pr_func_t imp; if (!fwd_sel) { //FIXME sel_register_typed_name is really not the way to go about @@ -1372,7 +1372,7 @@ static void rua_obj_set_error_handler (progs_t *pr) { //probj_t *probj = pr->pr_objective_resources; - //func_t func = P_INT (pr, 0); + //pr_func_t func = P_INT (pr, 0); //arglist //XXX PR_RunError (pr, "%s, not implemented", __FUNCTION__); @@ -1406,7 +1406,7 @@ rua_obj_msg_sendv (progs_t *pr) pr_id_t *receiver = &P_STRUCT (pr, pr_id_t, 0); pr_ptr_t sel = P_POINTER (pr, 1); pr_sel_t *op = &P_STRUCT (pr, pr_sel_t, 1); - func_t imp = obj_msg_lookup (probj, receiver, op); + pr_func_t imp = obj_msg_lookup (probj, receiver, op); __auto_type args = &P_PACKED (pr, pr_va_list_t, 2); int count = args->count; @@ -1530,7 +1530,7 @@ rua_obj_msgSend (progs_t *pr) probj_t *probj = pr->pr_objective_resources; pr_id_t *self = &P_STRUCT (pr, pr_id_t, 0); pr_sel_t *_cmd = &P_STRUCT (pr, pr_sel_t, 1); - func_t imp; + pr_func_t imp; if (!self) { R_INT (pr) = P_INT (pr, 0); @@ -1553,7 +1553,7 @@ rua_obj_msgSend_super (progs_t *pr) probj_t *probj = pr->pr_objective_resources; pr_super_t *super = &P_STRUCT (pr, pr_super_t, 0); pr_sel_t *_cmd = &P_STRUCT (pr, pr_sel_t, 1); - func_t imp; + pr_func_t imp; imp = obj_msg_lookup_super (probj, super, _cmd); if (!imp) { @@ -2248,13 +2248,13 @@ RUA_Obj_Init (progs_t *pr, int secure) PR_AddLoadFunc (pr, rua_obj_init_runtime); } -func_t +pr_func_t RUA_Obj_msg_lookup (progs_t *pr, pr_ptr_t _self, pr_ptr_t __cmd) { probj_t *probj = pr->pr_objective_resources; pr_id_t *self = &G_STRUCT (pr, pr_id_t, _self); pr_sel_t *_cmd = &G_STRUCT (pr, pr_sel_t, __cmd); - func_t imp; + pr_func_t imp; if (!self) return 0; diff --git a/libs/ruamoko/rua_stdlib.c b/libs/ruamoko/rua_stdlib.c index 8c375e405..2ef4d914a 100644 --- a/libs/ruamoko/rua_stdlib.c +++ b/libs/ruamoko/rua_stdlib.c @@ -56,7 +56,7 @@ typedef struct { progs_t *pr; - func_t func; + pr_func_t func; } function_t; static int @@ -87,7 +87,7 @@ bi_bsearch (progs_t *pr) const void *array = P_GPOINTER (pr, 1); size_t nmemb = P_INT (pr, 2); size_t size = P_INT (pr, 3) * sizeof (pr_int_t); - func_t cmp = P_FUNCTION (pr, 4); + pr_func_t cmp = P_FUNCTION (pr, 4); void *p = 0; if (!cmp) { @@ -106,7 +106,7 @@ bi_fbsearch (progs_t *pr) const void *array = P_GPOINTER (pr, 1); size_t nmemb = P_INT (pr, 2); size_t size = P_INT (pr, 3) * sizeof (pr_int_t); - func_t cmp = P_FUNCTION (pr, 4); + pr_func_t cmp = P_FUNCTION (pr, 4); void *p = 0; if (!cmp) { @@ -124,7 +124,7 @@ bi_qsort (progs_t *pr) void *array = P_GPOINTER (pr, 0); size_t nmemb = P_INT (pr, 1); size_t size = P_INT (pr, 2) * sizeof (pr_int_t); - func_t cmp = P_FUNCTION (pr, 3); + pr_func_t cmp = P_FUNCTION (pr, 3); if (!cmp) { qsort (array, nmemb, size, int_compare); diff --git a/nq/include/sv_progs.h b/nq/include/sv_progs.h index a660b4e77..4a74bfb38 100644 --- a/nq/include/sv_progs.h +++ b/nq/include/sv_progs.h @@ -76,18 +76,18 @@ typedef struct { extern sv_globals_t sv_globals; typedef struct { - func_t main; - func_t StartFrame; - func_t PlayerPreThink; - func_t PlayerPostThink; - func_t ClientKill; - func_t ClientConnect; - func_t PutClientInServer; - func_t ClientDisconnect; - func_t SetNewParms; - func_t SetChangeParms; + pr_func_t main; + pr_func_t StartFrame; + pr_func_t PlayerPreThink; + pr_func_t PlayerPostThink; + pr_func_t ClientKill; + pr_func_t ClientConnect; + pr_func_t PutClientInServer; + pr_func_t ClientDisconnect; + pr_func_t SetNewParms; + pr_func_t SetChangeParms; - func_t EndFrame; + pr_func_t EndFrame; } sv_funcs_t; extern sv_funcs_t sv_funcs; @@ -115,9 +115,9 @@ typedef struct pr_int_t mins; //vec3_t pr_int_t maxs; //vec3_t pr_int_t size; //vec3_t - pr_int_t touch; //func_t - pr_int_t think; //func_t - pr_int_t blocked; //func_t + pr_int_t touch; //pr_func_t + pr_int_t think; //pr_func_t + pr_int_t blocked; //pr_func_t pr_int_t nextthink; //float pr_int_t groundentity; //int pr_int_t health; //float diff --git a/nq/source/sv_progs.c b/nq/source/sv_progs.c index 65c7ee495..69dd7254c 100644 --- a/nq/source/sv_progs.c +++ b/nq/source/sv_progs.c @@ -397,13 +397,13 @@ resolve_functions (progs_t *pr, sv_def_t *def, int mode) if (mode == 2) { for (; def->name; def++) - *(func_t *) def->field = G_FUNCTION (pr, def->offset); + *(pr_func_t *) def->field = G_FUNCTION (pr, def->offset); return 1; } for (; def->name; def++) { dfunc = PR_FindFunction (pr, def->name); if (dfunc) { - *(func_t *) def->field = dfunc - pr->pr_functions; + *(pr_func_t *) def->field = dfunc - pr->pr_functions; } else if (mode) { PR_Undefined (pr, "function", def->name); ret = 0; diff --git a/qw/include/sv_progs.h b/qw/include/sv_progs.h index b4d931c35..c158461de 100644 --- a/qw/include/sv_progs.h +++ b/qw/include/sv_progs.h @@ -71,25 +71,25 @@ typedef struct { extern sv_globals_t sv_globals; typedef struct { - func_t main; - func_t StartFrame; - func_t PlayerPreThink; - func_t PlayerPostThink; - func_t ClientKill; - func_t ClientConnect; - func_t PutClientInServer; - func_t ClientDisconnect; - func_t SetNewParms; - func_t SetChangeParms; + pr_func_t main; + pr_func_t StartFrame; + pr_func_t PlayerPreThink; + pr_func_t PlayerPostThink; + pr_func_t ClientKill; + pr_func_t ClientConnect; + pr_func_t PutClientInServer; + pr_func_t ClientDisconnect; + pr_func_t SetNewParms; + pr_func_t SetChangeParms; - func_t EndFrame; - func_t SpectatorConnect; - func_t SpectatorThink; - func_t SpectatorDisconnect; - func_t UserInfoCallback; - func_t UserInfoChanged; - func_t ChatMessage; - func_t LocalinfoChanged; + pr_func_t EndFrame; + pr_func_t SpectatorConnect; + pr_func_t SpectatorThink; + pr_func_t SpectatorDisconnect; + pr_func_t UserInfoCallback; + pr_func_t UserInfoChanged; + pr_func_t ChatMessage; + pr_func_t LocalinfoChanged; } sv_funcs_t; extern sv_funcs_t sv_funcs; @@ -116,9 +116,9 @@ typedef struct pr_int_t mins; //vec3_t pr_int_t maxs; //vec3_t pr_int_t size; //vec3_t - pr_int_t touch; //func_t - pr_int_t think; //func_t - pr_int_t blocked; //func_t + pr_int_t touch; //pr_func_t + pr_int_t think; //pr_func_t + pr_int_t blocked; //pr_func_t pr_int_t nextthink; //float pr_int_t groundentity; //int pr_int_t health; //float diff --git a/qw/source/sv_pr_cpqw.c b/qw/source/sv_pr_cpqw.c index 19be9ac13..eebb91ef4 100644 --- a/qw/source/sv_pr_cpqw.c +++ b/qw/source/sv_pr_cpqw.c @@ -45,7 +45,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "world.h" static struct { - func_t ClientCommand; + pr_func_t ClientCommand; } cpqw_funcs; /* @@ -796,7 +796,7 @@ static builtin_t builtins[] = { static struct { const char *name; - func_t *field; + pr_func_t *field; } cpqw_func_list[] = { {"ClientCommand", &cpqw_funcs.ClientCommand}, {"UserInfoChanged", &sv_funcs.UserInfoChanged}, @@ -841,7 +841,7 @@ cpqw_load (progs_t *pr) *cpqw_func_list[i].field = 0; if (f) - *cpqw_func_list[i].field = (func_t) (f - pr->pr_functions); + *cpqw_func_list[i].field = (pr_func_t) (f - pr->pr_functions); } ucmd_unknown = cpqw_user_cmd; return 1; diff --git a/qw/source/sv_pr_qwe.c b/qw/source/sv_pr_qwe.c index c5e5fb810..6c89a820b 100644 --- a/qw/source/sv_pr_qwe.c +++ b/qw/source/sv_pr_qwe.c @@ -56,9 +56,9 @@ #include "qw/include/sv_recorder.h" typedef struct { - func_t timeofday; - func_t ConsoleCmd; - func_t UserCmd; + pr_func_t timeofday; + pr_func_t ConsoleCmd; + pr_func_t UserCmd; } qwe_funcs_t; static qwe_funcs_t qwe_funcs; @@ -354,7 +354,7 @@ PF_calltimeofday (progs_t *pr) P_STRING (pr, 6) = PR_SetReturnString (pr, date.str); pr->pr_argc = 7; - PR_ExecuteProgram (pr, (func_t) (f - sv_pr_state.pr_functions)); + PR_ExecuteProgram (pr, (pr_func_t) (f - sv_pr_state.pr_functions)); PR_PopFrame (&sv_pr_state); } } @@ -508,7 +508,7 @@ static builtin_t builtins[] = { static struct { const char *name; - func_t *field; + pr_func_t *field; } qwe_func_list[] = { {"timeofday", &qwe_funcs.timeofday}, {"ConsoleCmd", &qwe_funcs.ConsoleCmd}, @@ -574,7 +574,7 @@ qwe_load (progs_t *pr) *qwe_func_list[i].field = 0; if (f) - *qwe_func_list[i].field = (func_t) (f - pr->pr_functions); + *qwe_func_list[i].field = (pr_func_t) (f - pr->pr_functions); } sv_cbuf->unknown_command = qwe_console_cmd; diff --git a/qw/source/sv_progs.c b/qw/source/sv_progs.c index 4510ee339..dee8842bd 100644 --- a/qw/source/sv_progs.c +++ b/qw/source/sv_progs.c @@ -430,13 +430,13 @@ resolve_functions (progs_t *pr, sv_def_t *def, int mode) if (mode == 2) { for (; def->name; def++) - *(func_t *) def->field = G_FUNCTION (pr, def->offset); + *(pr_func_t *) def->field = G_FUNCTION (pr, def->offset); return 1; } for (; def->name; def++) { dfunc = PR_FindFunction (pr, def->name); if (dfunc) { - *(func_t *) def->field = dfunc - pr->pr_functions; + *(pr_func_t *) def->field = dfunc - pr->pr_functions; } else if (mode) { PR_Undefined (pr, "function", def->name); ret = 0; diff --git a/qw/source/sv_user.c b/qw/source/sv_user.c index 2f37404b6..0d6ab4c3f 100644 --- a/qw/source/sv_user.c +++ b/qw/source/sv_user.c @@ -1332,7 +1332,7 @@ static void call_qc_hook (void *qc_hook) { *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, sv_player); - PR_ExecuteProgram (&sv_pr_state, (func_t) (intptr_t) qc_hook); + PR_ExecuteProgram (&sv_pr_state, (pr_func_t) (intptr_t) qc_hook); } static const char * diff --git a/ruamoko/qwaq/builtins/debug.c b/ruamoko/qwaq/builtins/debug.c index 4fa0b0c98..ba43ddcb5 100644 --- a/ruamoko/qwaq/builtins/debug.c +++ b/ruamoko/qwaq/builtins/debug.c @@ -301,7 +301,7 @@ qdb_get_state (progs_t *pr) pr_string_t file = 0; unsigned line = 0; unsigned staddr = tpr->pr_xstatement; - func_t func = 0; + pr_func_t func = 0; if (tpr->pr_xfunction) { func = tpr->pr_xfunction - tpr->function_table; @@ -374,14 +374,14 @@ qdb_get_event (progs_t *pr) event->what = target->event; switch (event->what) { case prd_subenter: - event->function = *(func_t *) target->param; + event->function = *(pr_func_t *) target->param; break; case prd_runerror: case prd_error: event->message = PR_SetReturnString (pr, *(char **) target->param); break; case prd_begin: - event->function = *(func_t *) target->param; + event->function = *(pr_func_t *) target->param; break; case prd_terminate: event->exit_code = *(int *) target->param; diff --git a/ruamoko/qwaq/builtins/graphics.c b/ruamoko/qwaq/builtins/graphics.c index 44426ae4a..847a13357 100644 --- a/ruamoko/qwaq/builtins/graphics.c +++ b/ruamoko/qwaq/builtins/graphics.c @@ -83,7 +83,7 @@ quit_f (void) } static progs_t *bi_rprogs; -static func_t qc2d; +static pr_func_t qc2d; static int event_handler_id; static void diff --git a/ruamoko/qwaq/qwaq.h b/ruamoko/qwaq/qwaq.h index 4bdc09435..cb16c9af9 100644 --- a/ruamoko/qwaq/qwaq.h +++ b/ruamoko/qwaq/qwaq.h @@ -19,7 +19,7 @@ typedef struct qwaq_thread_s { int rua_security; struct memhunk_s *hunk; struct hashlink_s *hashlink_freelist; - func_t main_func; + pr_func_t main_func; void *data; } qwaq_thread_t; diff --git a/tools/qfcc/include/obj_file.h b/tools/qfcc/include/obj_file.h index aecd3801a..a4861d29a 100644 --- a/tools/qfcc/include/obj_file.h +++ b/tools/qfcc/include/obj_file.h @@ -420,7 +420,7 @@ enum { \param q pointer to ::qfo_t struct \param s space index \param o offset into object file data space - \return func_t lvalue + \return pr_func_t lvalue \hideinitializer */ diff --git a/tools/qfcc/source/dump_globals.c b/tools/qfcc/source/dump_globals.c index 5bff7e2a0..2f39850e1 100644 --- a/tools/qfcc/source/dump_globals.c +++ b/tools/qfcc/source/dump_globals.c @@ -118,7 +118,7 @@ dump_def (progs_t *pr, pr_def_t *def, int indent) break; case ev_func: { - func_t func = G_FUNCTION (pr, offset); + pr_func_t func = G_FUNCTION (pr, offset); int start; if (func < pr->progs->numfunctions) { start = pr->pr_functions[func].first_statement; diff --git a/tools/qfcc/test/test-harness.c b/tools/qfcc/test/test-harness.c index b73b0916f..c0aa96b10 100644 --- a/tools/qfcc/test/test-harness.c +++ b/tools/qfcc/test/test-harness.c @@ -259,7 +259,7 @@ int main (int argc, char **argv) { dfunction_t *dfunc; - func_t main_func = 0; + pr_func_t main_func = 0; const char *name = "progs.dat"; pr_string_t *pr_argv; int pr_argc = 1, i; From 0748581cd6b95c89aba8baf413fde5cd7e5e61da Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 15:44:49 +0900 Subject: [PATCH 141/360] [gamecode] Tidy up progs type definitions A bit of whitespace and put them in order of the types enum --- include/QF/progs/pr_comp.h | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index fa7348161..aff321ffc 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -23,17 +23,17 @@ #include "QF/qtypes.h" -typedef double pr_double_t; -typedef float pr_float_t; -typedef int16_t pr_short_t; -typedef uint16_t pr_ushort_t; -typedef int32_t pr_int_t; -typedef uint32_t pr_uint_t; -typedef uint32_t pr_func_t; -typedef int64_t pr_long_t; -typedef uint64_t pr_ulong_t; -typedef pr_int_t pr_string_t; -typedef pr_uint_t pr_ptr_t; +typedef int32_t pr_string_t; +typedef float pr_float_t; +typedef uint32_t pr_func_t; +typedef uint32_t pr_ptr_t; +typedef int32_t pr_int_t; +typedef uint32_t pr_uint_t; +typedef int16_t pr_short_t; +typedef double pr_double_t; +typedef int64_t pr_long_t; +typedef uint64_t pr_ulong_t; +typedef uint16_t pr_ushort_t; #define PR_VEC_TYPE(t,n,s) \ typedef t n __attribute__ ((vector_size (s*sizeof (t)))) From cd30408675af68ce06516b8a4398287694e14a67 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 15:48:43 +0900 Subject: [PATCH 142/360] [gamecode] Rename ev_quat to ev_quaternion I much prefer the full name, though the short version is easier to type. --- include/QF/progs/pr_type_names.h | 2 +- libs/gamecode/pr_debug.c | 2 +- libs/gamecode/pr_exec.c | 24 +++++++-------- libs/gamecode/pr_parse.c | 2 +- libs/gamecode/pr_v6p_opcode.c | 52 ++++++++++++++++---------------- nq/source/sv_progs.c | 2 +- qw/source/sv_progs.c | 2 +- tools/qfcc/source/dot_expr.c | 2 +- tools/qfcc/source/dump_globals.c | 2 +- tools/qfcc/source/expr.c | 18 +++++------ tools/qfcc/source/expr_binary.c | 4 +-- tools/qfcc/source/expr_bool.c | 2 +- tools/qfcc/source/idstuff.c | 2 +- tools/qfcc/source/statements.c | 4 +-- tools/qfcc/source/type.c | 18 +++++------ tools/qfcc/source/value.c | 2 +- 16 files changed, 70 insertions(+), 70 deletions(-) diff --git a/include/QF/progs/pr_type_names.h b/include/QF/progs/pr_type_names.h index 712a3c74c..79dfaa4ff 100644 --- a/include/QF/progs/pr_type_names.h +++ b/include/QF/progs/pr_type_names.h @@ -38,7 +38,7 @@ EV_TYPE(entity) EV_TYPE(field) EV_TYPE(func) EV_TYPE(ptr) // end of v6 types -EV_TYPE(quat) +EV_TYPE(quaternion) EV_TYPE(int) EV_TYPE(uint) EV_TYPE(short) // value is embedded in the opcode diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index f06fdf39f..1f7e2a651 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -1053,7 +1053,7 @@ value_string (pr_debug_data_t *data, qfot_type_t *type, pr_type_t *value) case ev_ptr: raw_type_view.pointer_view (type, value, data); break; - case ev_quat: + case ev_quaternion: raw_type_view.quat_view (type, value, data); break; case ev_int: diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 3b5b8c6f3..65615b7fe 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -799,7 +799,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREP_Q_v6p: pointer = OPB(int); if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_quat); + PR_BoundsCheck (pr, pointer, ev_quaternion); } ptr = pr->pr_globals + pointer; QuatCopy (&OPA(float), &ptr->quat_var); @@ -921,7 +921,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_LOADB_Q_v6p: pointer = OPA(int) + OPB(int); if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_quat); + PR_BoundsCheck (pr, pointer, ev_quaternion); } ptr = pr->pr_globals + pointer; QuatCopy (&ptr->quat_var, &OPC(float)); @@ -960,7 +960,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_LOADBI_Q_v6p: pointer = OPA(int) + (short) st->b; if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_quat); + PR_BoundsCheck (pr, pointer, ev_quaternion); } ptr = pr->pr_globals + pointer; QuatCopy (&ptr->quat_var, &OPC(float)); @@ -968,7 +968,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_LOADBI_D_v6p: pointer = OPA(int) + (short) st->b; if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_quat); + PR_BoundsCheck (pr, pointer, ev_quaternion); } ptr = pr->pr_globals + pointer; OPC(double) = *(double *) ptr; @@ -1009,7 +1009,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREB_Q_v6p: pointer = OPB(int) + OPC(int); if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_quat); + PR_BoundsCheck (pr, pointer, ev_quaternion); } ptr = pr->pr_globals + pointer; QuatCopy (&OPA(float), &ptr->quat_var); @@ -1017,7 +1017,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREB_D_v6p: pointer = OPB(int) + OPC(int); if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_quat); + PR_BoundsCheck (pr, pointer, ev_quaternion); } ptr = pr->pr_globals + pointer; *(double *) ptr = OPA(double); @@ -1048,7 +1048,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREBI_Q_v6p: pointer = OPB(int) + (short) st->c; if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_quat); + PR_BoundsCheck (pr, pointer, ev_quaternion); } ptr = pr->pr_globals + pointer; QuatCopy (&OPA(float), &ptr->quat_var); @@ -1056,7 +1056,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREBI_D_v6p: pointer = OPB(int) + (short) st->c; if (pr_boundscheck->int_val) { - PR_BoundsCheck (pr, pointer, ev_quat); + PR_BoundsCheck (pr, pointer, ev_quaternion); } ptr = pr->pr_globals + pointer; *(double *) ptr = OPA(double); @@ -1152,7 +1152,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 4); - PR_BoundsCheck (pr, pointer, ev_quat); + PR_BoundsCheck (pr, pointer, ev_quaternion); } QuatCopy (&ptr->quat_var, &stk->quat_var); @@ -1210,7 +1210,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 4); - PR_BoundsCheck (pr, pointer, ev_quat); + PR_BoundsCheck (pr, pointer, ev_quaternion); } QuatCopy (&ptr->quat_var, &stk->quat_var); @@ -1308,7 +1308,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 4); - PR_BoundsCheck (pr, pointer, ev_quat); + PR_BoundsCheck (pr, pointer, ev_quaternion); } QuatCopy (&stk->quat_var, &ptr->quat_var); @@ -1366,7 +1366,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) if (pr_boundscheck->int_val) { check_stack_pointer (pr, stack, 4); - PR_BoundsCheck (pr, pointer, ev_quat); + PR_BoundsCheck (pr, pointer, ev_quaternion); } QuatCopy (&stk->quat_var, &ptr->quat_var); diff --git a/libs/gamecode/pr_parse.c b/libs/gamecode/pr_parse.c index 33ab39d3c..5f360c054 100644 --- a/libs/gamecode/pr_parse.c +++ b/libs/gamecode/pr_parse.c @@ -94,7 +94,7 @@ PR_UglyValueString (progs_t *pr, etype_t type, pr_type_t *val, dstring_t *line) case ev_vector: dsprintf (line, "%.9g %.9g %.9g", VectorExpand (&val->vector_var)); break; - case ev_quat: + case ev_quaternion: dsprintf (line, "%.9g %.9g %.9g %.9g", QuatExpand (&val->quat_var)); break; default: diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index 934a6ed69..6b8988474 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -97,32 +97,32 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { PROG_ID_VERSION, }, [OP_MUL_Q_v6p] = {"*", "mul.q", - ev_quat, ev_quat, ev_quat, + ev_quaternion, ev_quaternion, ev_quaternion, PROG_V6P_VERSION, }, [OP_MUL_FQ_v6p] = {"*", "mul.fq", - ev_float, ev_quat, ev_quat, + ev_float, ev_quaternion, ev_quaternion, PROG_V6P_VERSION, }, [OP_MUL_QF_v6p] = {"*", "mul.qf", - ev_quat, ev_float, ev_quat, + ev_quaternion, ev_float, ev_quaternion, PROG_V6P_VERSION, }, [OP_MUL_DQ_v6p] = {"*", "mul.dq", - ev_double, ev_quat, ev_quat, + ev_double, ev_quaternion, ev_quaternion, PROG_V6P_VERSION, }, [OP_MUL_QD_v6p] = {"*", "mul.qd", - ev_quat, ev_double, ev_quat, + ev_quaternion, ev_double, ev_quaternion, PROG_V6P_VERSION, }, [OP_MUL_QV_v6p] = {"*", "mul.qv", - ev_quat, ev_vector, ev_vector, + ev_quaternion, ev_vector, ev_vector, PROG_V6P_VERSION, }, [OP_CONJ_Q_v6p] = {"~", "conj.q", - ev_quat, ev_invalid, ev_quat, + ev_quaternion, ev_invalid, ev_quaternion, PROG_V6P_VERSION, "%Ga, %gc", }, @@ -157,7 +157,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { PROG_ID_VERSION, }, [OP_ADD_Q_v6p] = {"+", "add.q", - ev_quat, ev_quat, ev_quat, + ev_quaternion, ev_quaternion, ev_quaternion, PROG_V6P_VERSION, }, [OP_ADD_S_v6p] = {"+", "add.s", @@ -178,7 +178,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { PROG_ID_VERSION, }, [OP_SUB_Q_v6p] = {"-", "sub.q", - ev_quat, ev_quat, ev_quat, + ev_quaternion, ev_quaternion, ev_quaternion, PROG_V6P_VERSION, }, @@ -195,7 +195,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { PROG_ID_VERSION, }, [OP_EQ_Q_v6p] = {"==", "eq.q", - ev_quat, ev_quat, ev_int, + ev_quaternion, ev_quaternion, ev_int, PROG_V6P_VERSION, }, [OP_EQ_S_v6p] = {"==", "eq.s", @@ -224,7 +224,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { PROG_ID_VERSION, }, [OP_NE_Q_v6p] = {"!=", "ne.q", - ev_quat, ev_quat, ev_int, + ev_quaternion, ev_quaternion, ev_int, PROG_V6P_VERSION, }, [OP_NE_S_v6p] = {"!=", "ne.s", @@ -305,7 +305,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga.%Gb(%Ec), %gc", }, [OP_LOAD_Q_v6p] = {".", "load.q", - ev_entity, ev_field, ev_quat, + ev_entity, ev_field, ev_quaternion, PROG_V6P_VERSION, "%Ga.%Gb(%Ec), %gc", }, @@ -356,7 +356,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "*(%Ga + %Gb), %gc", }, [OP_LOADB_Q_v6p] = {".", "loadb.q", - ev_ptr, ev_int, ev_quat, + ev_ptr, ev_int, ev_quaternion, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, @@ -407,7 +407,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "*(%Ga + %sb), %gc", }, [OP_LOADBI_Q_v6p] = {".", "loadbi.q", - ev_ptr, ev_short, ev_quat, + ev_ptr, ev_short, ev_quaternion, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, @@ -469,7 +469,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, %gc", }, [OP_ADDRESS_Q_v6p] = {"&", "address.q", - ev_quat, ev_invalid, ev_ptr, + ev_quaternion, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, @@ -562,7 +562,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, %gb", }, [OP_STORE_Q_v6p] = {"=", "store.q", - ev_quat, ev_quat, ev_invalid, + ev_quaternion, ev_quaternion, ev_invalid, PROG_V6P_VERSION, "%Ga, %gb", }, @@ -613,7 +613,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, *%Gb", }, [OP_STOREP_Q_v6p] = {".=", "storep.q", - ev_quat, ev_ptr, ev_invalid, + ev_quaternion, ev_ptr, ev_invalid, PROG_V6P_VERSION, "%Ga, *%Gb", }, @@ -664,7 +664,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, *(%Gb + %Gc)", }, [OP_STOREB_Q_v6p] = {".=", "storeb.q", - ev_quat, ev_ptr, ev_int, + ev_quaternion, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, @@ -715,7 +715,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, *(%Gb + %sc)", }, [OP_STOREBI_Q_v6p] = {".=", "storebi.q", - ev_quat, ev_ptr, ev_short, + ev_quaternion, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, @@ -778,7 +778,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, %gc", }, [OP_NOT_Q_v6p] = {"!", "not.q", - ev_quat, ev_invalid, ev_int, + ev_quaternion, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, @@ -1203,7 +1203,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga", }, [OP_PUSH_Q_v6p] = {"", "push.q", - ev_quat, ev_invalid, ev_invalid, + ev_quaternion, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, @@ -1254,7 +1254,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "*(%Ga + %Gb)", }, [OP_PUSHB_Q_v6p] = {"", "pushb.q", - ev_ptr, ev_int, ev_quat, + ev_ptr, ev_int, ev_quaternion, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, @@ -1305,7 +1305,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "*(%Ga + %sb)", }, [OP_PUSHBI_Q_v6p] = {"", "pushbi.q", - ev_ptr, ev_short, ev_quat, + ev_ptr, ev_short, ev_quaternion, PROG_V6P_VERSION, "*(%Ga + %sb)", }, @@ -1356,7 +1356,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%ga", }, [OP_POP_Q_v6p] = {"", "pop.q", - ev_quat, ev_invalid, ev_invalid, + ev_quaternion, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%ga", }, @@ -1407,7 +1407,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "*(%Ga + %Gb)", }, [OP_POPB_Q_v6p] = {"", "popb.q", - ev_ptr, ev_int, ev_quat, + ev_ptr, ev_int, ev_quaternion, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, @@ -1458,7 +1458,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "*(%Ga + %sb)", }, [OP_POPBI_Q_v6p] = {"", "popbi.q", - ev_ptr, ev_short, ev_quat, + ev_ptr, ev_short, ev_quaternion, PROG_V6P_VERSION, "*(%Ga + %sb)", }, diff --git a/nq/source/sv_progs.c b/nq/source/sv_progs.c index 69dd7254c..6da6199f2 100644 --- a/nq/source/sv_progs.c +++ b/nq/source/sv_progs.c @@ -344,7 +344,7 @@ set_address (sv_def_t *def, void *address) break; case ev_float: case ev_vector: - case ev_quat: + case ev_quaternion: *(float **)def->field = (float *) address; break; case ev_double: diff --git a/qw/source/sv_progs.c b/qw/source/sv_progs.c index dee8842bd..d0636718c 100644 --- a/qw/source/sv_progs.c +++ b/qw/source/sv_progs.c @@ -377,7 +377,7 @@ set_address (sv_def_t *def, void *address) break; case ev_float: case ev_vector: - case ev_quat: + case ev_quaternion: *(float **)def->field = (float *) address; break; case ev_double: diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index 19081fd48..84d0acc3f 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -540,7 +540,7 @@ print_value (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) e->e.value->v.vector_val[1], e->e.value->v.vector_val[2]); break; - case ev_quat: + case ev_quaternion: label = va (0, "'%g %g %g %g'", e->e.value->v.quaternion_val[0], e->e.value->v.quaternion_val[1], diff --git a/tools/qfcc/source/dump_globals.c b/tools/qfcc/source/dump_globals.c index 2f39850e1..69cc1e61a 100644 --- a/tools/qfcc/source/dump_globals.c +++ b/tools/qfcc/source/dump_globals.c @@ -134,7 +134,7 @@ dump_def (progs_t *pr, pr_def_t *def, int indent) case ev_ptr: comment = va (0, " %x", G_INT (pr, offset)); break; - case ev_quat: + case ev_quaternion: comment = va (0, " '%g %g %g %g'", G_QUAT (pr, offset)[0], G_QUAT (pr, offset)[1], diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 61e42c552..19af1437f 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1079,10 +1079,10 @@ is_quaternion_val (expr_t *e) { if (e->type == ex_nil) return 1; - if (e->type == ex_value && e->e.value->lltype == ev_quat) + if (e->type == ex_value && e->e.value->lltype == ev_quaternion) return 1; if (e->type == ex_symbol && e->e.symbol->sy_type == sy_const - && e->e.symbol->type->type == ev_quat) + && e->e.symbol->type->type == ev_quaternion) return 1; return 0; } @@ -1092,14 +1092,14 @@ expr_quaternion (expr_t *e) { if (e->type == ex_nil) return quat_origin; - if (e->type == ex_value && e->e.value->lltype == ev_quat) + if (e->type == ex_value && e->e.value->lltype == ev_quaternion) return e->e.value->v.quaternion_val; if (e->type == ex_symbol && e->e.symbol->sy_type == sy_const - && e->e.symbol->type->type == ev_quat) + && e->e.symbol->type->type == ev_quaternion) return e->e.symbol->s.value->v.quaternion_val; if (e->type == ex_symbol && e->e.symbol->sy_type == sy_var && e->e.symbol->s.def->constant - && e->e.symbol->s.def->type->type == ev_quat) + && e->e.symbol->s.def->type->type == ev_quaternion) return D_QUAT (e->e.symbol->s.def); internal_error (e, "not a quaternion constant"); } @@ -1459,7 +1459,7 @@ field_expr (expr_t *e1, expr_t *e2) e = new_address_expr (ivar->type, e1, e2); return unary_expr ('.', e); } - } else if (t1->type == ev_vector || t1->type == ev_quat + } else if (t1->type == ev_vector || t1->type == ev_quaternion || is_struct (t1)) { symbol_t *field; @@ -1707,7 +1707,7 @@ unary_expr (int op, expr_t *e) case ev_vector: VectorNegate (expr_vector (e), v); return new_vector_expr (v); - case ev_quat: + case ev_quaternion: QuatNegate (expr_vector (e), q); return new_vector_expr (q); case ev_long: @@ -1809,7 +1809,7 @@ unary_expr (int op, expr_t *e) return new_int_expr (!expr_float (e)); case ev_vector: return new_int_expr (!VectorIsZero (expr_vector (e))); - case ev_quat: + case ev_quaternion: return new_int_expr (!QuatIsZero (expr_quaternion (e))); case ev_long: case ev_ulong: @@ -1882,7 +1882,7 @@ unary_expr (int op, expr_t *e) return error (e, "invalid type for unary ~"); case ev_float: return new_float_expr (~(int) expr_float (e)); - case ev_quat: + case ev_quaternion: QuatConj (expr_vector (e), q); return new_vector_expr (q); case ev_long: diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index 7610b4542..dfd02b5c8 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -534,7 +534,7 @@ static expr_type_t *string_x[ev_type_count] = { 0, // ev_field 0, // ev_func 0, // ev_ptr - 0, // ev_quat + 0, // ev_quaternion 0, // ev_int 0, // ev_uint 0, // ev_short @@ -630,7 +630,7 @@ static expr_type_t *pointer_x[ev_type_count] = { 0, // ev_field 0, // ev_func pointer_pointer, - 0, // ev_quat + 0, // ev_quaternion pointer_int, pointer_uint, pointer_short, diff --git a/tools/qfcc/source/expr_bool.c b/tools/qfcc/source/expr_bool.c index 52b4de683..5055d38d5 100644 --- a/tools/qfcc/source/expr_bool.c +++ b/tools/qfcc/source/expr_bool.c @@ -134,7 +134,7 @@ test_expr (expr_t *e) return new_alias_expr (type_default, e); case ev_ptr: return new_alias_expr (type_default, e); - case ev_quat: + case ev_quaternion: new = new_quaternion_expr (zero); break; case ev_invalid: diff --git a/tools/qfcc/source/idstuff.c b/tools/qfcc/source/idstuff.c index f78658247..9fb7f5003 100644 --- a/tools/qfcc/source/idstuff.c +++ b/tools/qfcc/source/idstuff.c @@ -230,7 +230,7 @@ WriteProgdefs (dprograms_t *progs, const char *filename) case ev_vector: dasprintf (dstr, "\tvec3_t\t%s;\n", name); break; - case ev_quat: + case ev_quaternion: dasprintf (dstr, "\tquat_t\t%s;\n", name); break; case ev_string: diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index a0aa7997f..8e6b01232 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -134,7 +134,7 @@ operand_string (operand_t *op) op->value->v.vector_val[0], op->value->v.vector_val[1], op->value->v.vector_val[2]); - case ev_quat: + case ev_quaternion: return va (0, "'%g %g %g %g'", op->value->v.quaternion_val[0], op->value->v.quaternion_val[1], @@ -221,7 +221,7 @@ _print_operand (operand_t *op) printf (" %g", op->value->v.vector_val[1]); printf (" %g'", op->value->v.vector_val[2]); break; - case ev_quat: + case ev_quaternion: printf ("'%g", op->value->v.quaternion_val[0]); printf (" %g", op->value->v.quaternion_val[1]); printf (" %g", op->value->v.quaternion_val[2]); diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index de6709c9d..c29c910bc 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -74,7 +74,7 @@ type_t type_function = { ev_func, "function", 1, ty_basic, {{&type_void}} }; type_t type_pointer = { ev_ptr, "pointer", 1, ty_basic, {{&type_void}} }; -type_t type_quaternion = { ev_quat, "quaternion", 4 }; +type_t type_quaternion = { ev_quaternion, "quaternion", 4 }; type_t type_int = { ev_int, "int", 1 }; type_t type_uint = { ev_uint, "uint", 1 }; type_t type_short = { ev_short, "short", 1 }; @@ -185,7 +185,7 @@ free_type (type_t *type) case ev_vector: case ev_entity: case ev_type_count: - case ev_quat: + case ev_quaternion: case ev_int: case ev_uint: case ev_long: @@ -227,7 +227,7 @@ copy_chain (type_t *type, type_t *append) case ev_vector: case ev_entity: case ev_type_count: - case ev_quat: + case ev_quaternion: case ev_int: case ev_uint: case ev_long: @@ -280,7 +280,7 @@ append_type (type_t *type, type_t *new) case ev_vector: case ev_entity: case ev_type_count: - case ev_quat: + case ev_quaternion: case ev_int: case ev_uint: case ev_long: @@ -659,7 +659,7 @@ print_type_str (dstring_t *str, const type_t *type) case ev_float: case ev_vector: case ev_entity: - case ev_quat: + case ev_quaternion: case ev_int: case ev_uint: case ev_long: @@ -819,7 +819,7 @@ encode_type (dstring_t *encoding, const type_t *type) dasprintf (encoding, "^"); encode_type (encoding, type); return; - case ev_quat: + case ev_quaternion: dasprintf (encoding, "Q"); return; case ev_int: @@ -936,7 +936,7 @@ int is_quaternion (const type_t *type) { type = unalias_type (type); - return type->type == ev_quat; + return type->type == ev_quaternion; } int @@ -945,7 +945,7 @@ is_math (const type_t *type) type = unalias_type (type); etype_t t = type->type; - return t == ev_vector || t == ev_quat || is_scalar (type); + return t == ev_vector || t == ev_quaternion || is_scalar (type); } int @@ -1258,7 +1258,7 @@ init_types (void) make_structure ("@va_list", 's', va_list_struct, &type_va_list); make_structure ("@quaternion", 's', quaternion_struct, &type_quaternion); - type_quaternion.type = ev_quat; + type_quaternion.type = ev_quaternion; type_quaternion.meta = ty_basic; { symbol_t *sym; diff --git a/tools/qfcc/source/value.c b/tools/qfcc/source/value.c index 73b3b47ab..7cdc55782 100644 --- a/tools/qfcc/source/value.c +++ b/tools/qfcc/source/value.c @@ -533,7 +533,7 @@ emit_value (ex_value_t *value, def_t *def) tab = vector_imm_defs; type = &type_vector; break; - case ev_quat: + case ev_quaternion: tab = quaternion_imm_defs; type = &type_quaternion; break; From 2c52e26d1ad89025dff6749f8a29ce241098dc80 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 15:50:32 +0900 Subject: [PATCH 143/360] [gamecode] Be more consistent with access types Eg, pointers via ptr, entities via entity, etc. --- libs/gamecode/pr_exec.c | 197 ++++++++++++++++++++-------------------- 1 file changed, 97 insertions(+), 100 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 65615b7fe..7ca7d6ad9 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -458,7 +458,7 @@ check_stack_pointer (progs_t *pr, pr_ptr_t stack, int size) } static inline void -pr_memset (pr_type_t *dst, int val, int count) +pr_memset (pr_type_t *dst, int val, pr_uint_t count) { while (count-- > 0) { (*dst++).int_var = val; @@ -691,37 +691,34 @@ pr_exec_quakec (progs_t *pr, int exitdepth) OPC(int) = QuatIsZero (&OPA(float)); break; case OP_NOT_S_v6p: - OPC(int) = !OPA(string) || - !*PR_GetString (pr, OPA(string)); + OPC(int) = !OPA(string) || !*PR_GetString (pr, OPA(string)); break; case OP_NOT_FN_v6p: - OPC(int) = !OPA(uint); + OPC(int) = !OPA(func); break; case OP_NOT_ENT_v6p: - OPC(int) = !OPA(uint); + OPC(int) = !OPA(entity); break; case OP_EQ_F_v6p: OPC(int) = OPA(float) == OPB(float); break; case OP_EQ_V_v6p: - OPC(int) = VectorCompare (&OPA(float), - &OPB(float)); + OPC(int) = VectorCompare (&OPA(float), &OPB(float)); break; case OP_EQ_Q_v6p: OPC(int) = QuatCompare (&OPA(float), &OPB(float)); break; case OP_EQ_E_v6p: - OPC(int) = OPA(int) == OPB(int); + OPC(int) = OPA(field) == OPB(field); break; case OP_EQ_FN_v6p: - OPC(int) = OPA(uint) == OPB(uint); + OPC(int) = OPA(func) == OPB(func); break; case OP_NE_F_v6p: OPC(int) = OPA(float) != OPB(float); break; case OP_NE_V_v6p: - OPC(int) = !VectorCompare (&OPA(float), - &OPB(float)); + OPC(int) = !VectorCompare (&OPA(float), &OPB(float)); break; case OP_NE_Q_v6p: OPC(int) = !QuatCompare (&OPA(float), &OPB(float)); @@ -748,10 +745,10 @@ pr_exec_quakec (progs_t *pr, int exitdepth) } break; case OP_NE_E_v6p: - OPC(int) = OPA(int) != OPB(int); + OPC(int) = OPA(entity) != OPB(entity); break; case OP_NE_FN_v6p: - OPC(int) = OPA(uint) != OPB(uint); + OPC(int) = OPA(func) != OPB(func); break; // ================== @@ -781,7 +778,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREP_FN_v6p: // pointers case OP_STOREP_I_v6p: case OP_STOREP_P_v6p: - pointer = OPB(int); + pointer = OPB(ptr); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_int); } @@ -789,7 +786,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr->int_var = OPA(int); break; case OP_STOREP_V_v6p: - pointer = OPB(int); + pointer = OPB(ptr); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); } @@ -797,7 +794,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) VectorCopy (&OPA(float), &ptr->vector_var); break; case OP_STOREP_Q_v6p: - pointer = OPB(int); + pointer = OPB(ptr); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quaternion); } @@ -805,7 +802,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) QuatCopy (&OPA(float), &ptr->quat_var); break; case OP_STOREP_D_v6p: - pointer = OPB(int); + pointer = OPB(ptr); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_double); } @@ -815,17 +812,17 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_ADDRESS_v6p: if (pr_boundscheck->int_val) { - if (OPA(uint) >= pr->pr_edict_area_size) + if (OPA(entity) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to address an out " "of bounds edict"); - if (OPA(uint) == 0 && pr->null_bad) + if (OPA(entity) == 0 && pr->null_bad) PR_RunError (pr, "assignment to world entity"); - if (OPB(uint) >= pr->progs->entityfields) + if (OPB(field) >= pr->progs->entityfields) PR_RunError (pr, "Progs attempted to address an " "invalid field in an edict"); } - fldofs = OPA(uint) + OPB(int); - OPC(int) = &pr->pr_edict_area[fldofs] - pr->pr_globals; + fldofs = OPA(entity) + OPB(field); + OPC(ptr) = &pr->pr_edict_area[fldofs] - pr->pr_globals; break; case OP_ADDRESS_VOID_v6p: case OP_ADDRESS_F_v6p: @@ -849,50 +846,50 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_LOAD_I_v6p: case OP_LOAD_P_v6p: if (pr_boundscheck->int_val) { - if (OPA(uint) >= pr->pr_edict_area_size) + if (OPA(entity) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to read an out of " "bounds edict number"); - if (OPB(uint) >= pr->progs->entityfields) + if (OPB(field) >= pr->progs->entityfields) PR_RunError (pr, "Progs attempted to read an invalid " "field in an edict"); } - fldofs = OPA(uint) + OPB(int); + fldofs = OPA(entity) + OPB(field); OPC(int) = pr->pr_edict_area[fldofs].int_var; break; case OP_LOAD_V_v6p: if (pr_boundscheck->int_val) { - if (OPA(uint) >= pr->pr_edict_area_size) + if (OPA(entity) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to read an out of " "bounds edict number"); - if (OPB(uint) + 2 >= pr->progs->entityfields) + if (OPB(field) + 2 >= pr->progs->entityfields) PR_RunError (pr, "Progs attempted to read an invalid " "field in an edict"); } - fldofs = OPA(uint) + OPB(int); + fldofs = OPA(entity) + OPB(field); memcpy (op_c, &pr->pr_edict_area[fldofs], 3 * sizeof (*op_c)); break; case OP_LOAD_Q_v6p: if (pr_boundscheck->int_val) { - if (OPA(uint) >= pr->pr_edict_area_size) + if (OPA(entity) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to read an out of " "bounds edict number"); - if (OPB(uint) + 3 >= pr->progs->entityfields) + if (OPB(field) + 3 >= pr->progs->entityfields) PR_RunError (pr, "Progs attempted to read an invalid " "field in an edict"); } - fldofs = OPA(uint) + OPB(int); + fldofs = OPA(entity) + OPB(field); memcpy (op_c, &pr->pr_edict_area[fldofs], 4 * sizeof (*op_c)); break; case OP_LOAD_D_v6p: if (pr_boundscheck->int_val) { - if (OPA(uint) >= pr->pr_edict_area_size) + if (OPA(entity) >= pr->pr_edict_area_size) PR_RunError (pr, "Progs attempted to read an out of " "bounds edict number"); - if (OPB(uint) + 1 >= pr->progs->entityfields) + if (OPB(field) + 1 >= pr->progs->entityfields) PR_RunError (pr, "Progs attempted to read an invalid " "field in an edict"); } - fldofs = OPA(uint) + OPB(int); + fldofs = OPA(entity) + OPB(field); memcpy (op_c, &pr->pr_edict_area[fldofs], sizeof (double)); break; @@ -903,7 +900,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_LOADB_FN_v6p: case OP_LOADB_I_v6p: case OP_LOADB_P_v6p: - pointer = OPA(int) + OPB(int); + pointer = OPA(entity) + OPB(field); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_int); } @@ -911,7 +908,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) OPC(int) = ptr->int_var; break; case OP_LOADB_V_v6p: - pointer = OPA(int) + OPB(int); + pointer = OPA(entity) + OPB(field); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); } @@ -919,7 +916,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) VectorCopy (&ptr->vector_var, &OPC(float)); break; case OP_LOADB_Q_v6p: - pointer = OPA(int) + OPB(int); + pointer = OPA(entity) + OPB(field); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quaternion); } @@ -927,7 +924,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) QuatCopy (&ptr->quat_var, &OPC(float)); break; case OP_LOADB_D_v6p: - pointer = OPA(int) + OPB(int); + pointer = OPA(entity) + OPB(field); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_double); } @@ -942,7 +939,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_LOADBI_FN_v6p: case OP_LOADBI_I_v6p: case OP_LOADBI_P_v6p: - pointer = OPA(int) + (short) st->b; + pointer = OPA(ptr) + (short) st->b; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_int); } @@ -950,7 +947,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) OPC(int) = ptr->int_var; break; case OP_LOADBI_V_v6p: - pointer = OPA(int) + (short) st->b; + pointer = OPA(ptr) + (short) st->b; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); } @@ -958,7 +955,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) VectorCopy (&ptr->vector_var, &OPC(float)); break; case OP_LOADBI_Q_v6p: - pointer = OPA(int) + (short) st->b; + pointer = OPA(ptr) + (short) st->b; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quaternion); } @@ -966,7 +963,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) QuatCopy (&ptr->quat_var, &OPC(float)); break; case OP_LOADBI_D_v6p: - pointer = OPA(int) + (short) st->b; + pointer = OPA(ptr) + (short) st->b; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quaternion); } @@ -975,13 +972,13 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_LEA_v6p: - pointer = OPA(int) + OPB(int); - OPC(int) = pointer; + pointer = OPA(ptr) + OPB(int); + OPC(ptr) = pointer; break; case OP_LEAI_v6p: - pointer = OPA(int) + (short) st->b; - OPC(int) = pointer; + pointer = OPA(ptr) + (short) st->b; + OPC(ptr) = pointer; break; case OP_STOREB_F_v6p: @@ -991,7 +988,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREB_FN_v6p: case OP_STOREB_I_v6p: case OP_STOREB_P_v6p: - pointer = OPB(int) + OPC(int); + pointer = OPB(ptr) + OPC(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_int); } @@ -999,7 +996,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr->int_var = OPA(int); break; case OP_STOREB_V_v6p: - pointer = OPB(int) + OPC(int); + pointer = OPB(ptr) + OPC(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); } @@ -1007,7 +1004,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) VectorCopy (&OPA(float), &ptr->vector_var); break; case OP_STOREB_Q_v6p: - pointer = OPB(int) + OPC(int); + pointer = OPB(ptr) + OPC(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quaternion); } @@ -1015,7 +1012,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) QuatCopy (&OPA(float), &ptr->quat_var); break; case OP_STOREB_D_v6p: - pointer = OPB(int) + OPC(int); + pointer = OPB(ptr) + OPC(int); if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quaternion); } @@ -1030,7 +1027,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) case OP_STOREBI_FN_v6p: case OP_STOREBI_I_v6p: case OP_STOREBI_P_v6p: - pointer = OPB(int) + (short) st->c; + pointer = OPB(ptr) + (short) st->c; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_int); } @@ -1038,7 +1035,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr->int_var = OPA(int); break; case OP_STOREBI_V_v6p: - pointer = OPB(int) + (short) st->c; + pointer = OPB(ptr) + (short) st->c; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_vector); } @@ -1046,7 +1043,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) VectorCopy (&OPA(float), &ptr->vector_var); break; case OP_STOREBI_Q_v6p: - pointer = OPB(int) + (short) st->c; + pointer = OPB(ptr) + (short) st->c; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quaternion); } @@ -1054,7 +1051,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) QuatCopy (&OPA(float), &ptr->quat_var); break; case OP_STOREBI_D_v6p: - pointer = OPB(int) + (short) st->c; + pointer = OPB(ptr) + (short) st->c; if (pr_boundscheck->int_val) { PR_BoundsCheck (pr, pointer, ev_quaternion); } @@ -1113,7 +1110,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr_ptr_t stack = *pr->globals.stack - 1; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA(int) + OPB(int); + pointer = OPA(ptr) + OPB(int); ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1130,7 +1127,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr_ptr_t stack = *pr->globals.stack - 3; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA(int) + OPB(int); + pointer = OPA(ptr) + OPB(int); ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1147,7 +1144,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr_ptr_t stack = *pr->globals.stack - 4; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA(int) + OPB(int); + pointer = OPA(ptr) + OPB(int); ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1171,7 +1168,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr_ptr_t stack = *pr->globals.stack - 1; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA(int) + st->b; + pointer = OPA(ptr) + st->b; ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1188,7 +1185,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr_ptr_t stack = *pr->globals.stack - 3; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA(int) + st->b; + pointer = OPA(ptr) + st->b; ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1205,7 +1202,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr_ptr_t stack = *pr->globals.stack - 4; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA(int) + st->b; + pointer = OPA(ptr) + st->b; ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1269,7 +1266,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA(int) + OPB(int); + pointer = OPA(ptr) + OPB(int); ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1286,7 +1283,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA(int) + OPB(int); + pointer = OPA(ptr) + OPB(int); ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1303,7 +1300,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA(int) + OPB(int); + pointer = OPA(ptr) + OPB(int); ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1327,7 +1324,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA(int) + st->b; + pointer = OPA(ptr) + st->b; ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1344,7 +1341,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA(int) + st->b; + pointer = OPA(ptr) + st->b; ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1361,7 +1358,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) pr_ptr_t stack = *pr->globals.stack; pr_type_t *stk = pr->pr_globals + stack; - pointer = OPA(int) + st->b; + pointer = OPA(ptr) + st->b; ptr = pr->pr_globals + pointer; if (pr_boundscheck->int_val) { @@ -1467,7 +1464,7 @@ op_rcall: op_call: pr->pr_xfunction->profile += profile - startprofile; startprofile = profile; - PR_CallFunction (pr, OPA(uint), pr->pr_return); + PR_CallFunction (pr, OPA(func), pr->pr_return); st = pr->pr_statements + pr->pr_xstatement; break; case OP_DONE_v6p: @@ -1500,7 +1497,7 @@ op_call: float time = *pr->globals.ftime + 0.1; pr->pr_edict_area[nextthink].float_var = time; pr->pr_edict_area[frame].float_var = OPA(float); - pr->pr_edict_area[think].func_var = OPB(uint); + pr->pr_edict_area[think].func_var = OPB(func); } break; case OP_STATE_F_v6p: @@ -1512,7 +1509,7 @@ op_call: float time = *pr->globals.ftime + OPC(float); pr->pr_edict_area[nextthink].float_var = time; pr->pr_edict_area[frame].float_var = OPA(float); - pr->pr_edict_area[think].func_var = OPB(uint); + pr->pr_edict_area[think].func_var = OPB(func); } break; case OP_ADD_I_v6p: @@ -1649,31 +1646,31 @@ op_call: break; case OP_MOVEP_v6p: if (pr_boundscheck->int_val) { - PR_BoundsCheckSize (pr, OPC(int), OPB(uint)); - PR_BoundsCheckSize (pr, OPA(int), OPB(uint)); + PR_BoundsCheckSize (pr, OPC(ptr), OPB(uint)); + PR_BoundsCheckSize (pr, OPA(ptr), OPB(uint)); } - memmove (pr->pr_globals + OPC(int), - pr->pr_globals + OPA(int), + memmove (pr->pr_globals + OPC(ptr), + pr->pr_globals + OPA(ptr), OPB(uint) * 4); break; case OP_MOVEPI_v6p: if (pr_boundscheck->int_val) { - PR_BoundsCheckSize (pr, OPC(int), st->b); - PR_BoundsCheckSize (pr, OPA(int), st->b); + PR_BoundsCheckSize (pr, OPC(ptr), st->b); + PR_BoundsCheckSize (pr, OPA(ptr), st->b); } - memmove (pr->pr_globals + OPC(int), - pr->pr_globals + OPA(int), + memmove (pr->pr_globals + OPC(ptr), + pr->pr_globals + OPA(ptr), st->b * 4); break; case OP_MEMSETI_v6p: - pr_memset (op_c, OPA(int), st->b); + pr_memset (op_c, OPA(ptr), st->b); break; case OP_MEMSETP_v6p: if (pr_boundscheck->int_val) { - PR_BoundsCheckSize (pr, OPC(ptr), OPB(int)); + PR_BoundsCheckSize (pr, OPC(ptr), OPB(uint)); } pr_memset (pr->pr_globals + OPC(ptr), OPA(int), - OPB(int)); + OPB(uint)); break; case OP_MEMSETPI_v6p: if (pr_boundscheck->int_val) { @@ -1720,7 +1717,7 @@ op_call: // LordHavoc: to be enabled when Progs version 7 (or whatever it will be numbered) is finalized /* case OP_BOUNDCHECK_v6p: - if (OPA(int) < 0 || OPA(int) >= st->b) { + if (OPA(ptr) >= st->b) { PR_RunError (pr, "Progs boundcheck failed at line number " "%d, value is < 0 or >= %d", st->b, st->c); } @@ -1763,20 +1760,20 @@ pr_address_mode (progs_t *pr, const dstatement_t *st, int mm_ind) break; case 1: // simple pointer dereference: *a - mm_offs = OPA(uint); + mm_offs = OPA(ptr); break; case 2: // constant indexed pointer: *a + b (supports -ve offset) - mm_offs = OPA(uint) + (short) st->b; + mm_offs = OPA(ptr) + (short) st->b; break; case 3: // variable indexed pointer: *a + *b (supports -ve offset) - mm_offs = OPA(uint) + OPB(int); + mm_offs = OPA(ptr) + OPB(int); break; case 4: // entity.field (equivalent to OP_LOAD_t_v6p) pr_ptr_t edict_area = pr->pr_edict_area - pr->pr_globals; - mm_offs = edict_area + OPA(uint) + OPB(uint); + mm_offs = edict_area + OPA(entity) + OPB(field); break; } return pr->pr_globals + mm_offs; @@ -1796,20 +1793,20 @@ pr_return_mode (progs_t *pr, const dstatement_t *st, int mm_ind) break; case 1: // simple pointer dereference: *a - mm_offs = OPA(uint); + mm_offs = OPA(ptr); break; case 2: // constant indexed pointer: *a + b (supports -ve offset) - mm_offs = OPA(uint) + (short) st->b; + mm_offs = OPA(ptr) + (short) st->b; break; case 3: // variable indexed pointer: *a + *b (supports -ve offset) - mm_offs = OPA(uint) + OPB(int); + mm_offs = OPA(ptr) + OPB(int); break; case 4: // entity.field (equivalent to OP_LOAD_t_v6p) pr_ptr_t edict_area = pr->pr_edict_area - pr->pr_globals; - mm_offs = edict_area + OPA(uint) + OPB(uint); + mm_offs = edict_area + OPA(entity) + OPB(field); break; } return pr->pr_globals + mm_offs; @@ -1829,16 +1826,16 @@ pr_call_mode (progs_t *pr, const dstatement_t *st, int mm_ind) break; case 2: // constant indexed pointer: *a + b (supports -ve offset) - mm_offs = OPA(uint) + (short) st->b; + mm_offs = OPA(ptr) + (short) st->b; break; case 3: // variable indexed pointer: *a + *b (supports -ve offset) - mm_offs = OPA(uint) + OPB(int); + mm_offs = OPA(ptr) + OPB(int); break; case 4: // entity.field (equivalent to OP_LOAD_t_v6p) pr_ptr_t edict_area = pr->pr_edict_area - pr->pr_globals; - mm_offs = edict_area + OPA(uint) + OPB(uint); + mm_offs = edict_area + OPA(entity) + OPB(field); break; } return pr->pr_globals + mm_offs; @@ -1858,15 +1855,15 @@ pr_jump_mode (progs_t *pr, const dstatement_t *st, int jump_ind) break; case 1: // simple pointer dereference: *a - jump_offs = OPA(uint); + jump_offs = OPA(ptr); break; case 2: // constant indexed pointer: *a + b (supports -ve offset) - jump_offs = OPA(uint) + (short) st->b; + jump_offs = OPA(ptr) + (short) st->b; break; case 3: // variable indexed pointer: *a + *b (supports -ve offset) - jump_offs = OPA(uint) + OPB(int); + jump_offs = OPA(ptr) + OPB(int); break; } if (pr_boundscheck->int_val && jump_offs >= pr->progs->numstatements) { @@ -1941,7 +1938,7 @@ pr_with (progs_t *pr, const dstatement_t *st) return; case 7: // relative to edict_area (only +ve) - *base = edict_area + OPB(uint); + *base = edict_area + OPB(field); return; case 8: @@ -3286,11 +3283,11 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) memmove (op_c, op_a, st->b * sizeof (pr_type_t)); break; case OP_MOVE_P: - memmove (pr->pr_globals + OPC(int), pr->pr_globals + OPA(int), + memmove (pr->pr_globals + OPC(ptr), pr->pr_globals + OPA(ptr), OPB(uint) * sizeof (pr_type_t)); break; case OP_MOVE_PI: - memmove (pr->pr_globals + OPC(int), pr->pr_globals + OPA(int), + memmove (pr->pr_globals + OPC(ptr), pr->pr_globals + OPA(ptr), st->b * sizeof (pr_type_t)); break; case OP_STATE_ft: @@ -3310,10 +3307,10 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) pr_memset (op_c, OPA(int), st->b); break; case OP_MEMSET_P: - pr_memset (pr->pr_globals + OPC(int), OPA(int), OPB(uint)); + pr_memset (pr->pr_globals + OPC(ptr), OPA(int), OPB(uint)); break; case OP_MEMSET_PI: - pr_memset (pr->pr_globals + OPC(int), OPA(int), st->b); + pr_memset (pr->pr_globals + OPC(ptr), OPA(int), st->b); break; case OP_STATE_ftt: { From 25f8d3a23def67c00dc6d193476befb84ac035cb Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 15:53:31 +0900 Subject: [PATCH 144/360] [gamecode] Use pr_type_names.h for type sizes The goal of the previous mess of commits. Ruamoko needs to wait until qfcc has the new types. --- include/QF/progs/pr_comp.h | 4 ++++ libs/gamecode/pr_opcode.c | 19 ++++--------------- ruamoko/lib/types.r | 4 +++- 3 files changed, 11 insertions(+), 16 deletions(-) diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index aff321ffc..7f52cb21d 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -25,8 +25,12 @@ typedef int32_t pr_string_t; typedef float pr_float_t; +typedef float pr_vector_t[3]; +typedef uint32_t pr_entity_t; +typedef uint32_t pr_field_t; typedef uint32_t pr_func_t; typedef uint32_t pr_ptr_t; +typedef float pr_quaternion_t[4]; typedef int32_t pr_int_t; typedef uint32_t pr_uint_t; typedef int16_t pr_short_t; diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index 0f1cb1258..8fb79e851 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -33,22 +33,11 @@ #include "QF/progs.h" +typedef pr_type_t pr_void_t; // so size of void is 1 + +#define EV_TYPE(type) (sizeof (pr_##type##_t) / sizeof (pr_int_t)), VISIBLE const pr_ushort_t pr_type_size[ev_type_count] = { - 1, // ev_void - 1, // ev_string - 1, // ev_float - 3, // ev_vector - 1, // ev_entity - 1, // ev_field - 1, // ev_func - 1, // ev_pointer - 4, // ev_quat - 1, // ev_int - 1, // ev_uint - 0, // ev_short value in opcode - 2, // ev_double - 2, // ev_long - 2, // ev_ulong +#include "QF/progs/pr_type_names.h" 0, // ev_invalid not a valid/simple type }; diff --git a/ruamoko/lib/types.r b/ruamoko/lib/types.r index f732cc8d0..0445e0510 100644 --- a/ruamoko/lib/types.r +++ b/ruamoko/lib/types.r @@ -11,8 +11,10 @@ string ty_meta_name[7] = { "alias", }; -//FIXME use pr_type_names.h +//FIXME use pr_type_names.h, but need to fix unsigned, and add missing types +//#define EV_TYPE(type) sizeof(type), int pr_type_size[ev_type_count] = { +//#include 1, // ev_void 1, // ev_string 1, // ev_float From ed501b7734ed402f0d296160146af509fe7825f8 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 18:41:39 +0900 Subject: [PATCH 145/360] [gamecode] Specify the alignment for progs types And provide a table for such for qfcc and the like. With this, using pr_double_t (for example) in C will cause the double value to always be 8-byte aligned and thus structures shared between gcc and qfcc will be consistent (with a little fuss to take care of the warts). --- include/QF/progs/pr_comp.h | 31 ++++++++++++++++--------------- libs/gamecode/pr_opcode.c | 6 ++++++ 2 files changed, 22 insertions(+), 15 deletions(-) diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 7f52cb21d..5d66fc323 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -23,21 +23,21 @@ #include "QF/qtypes.h" -typedef int32_t pr_string_t; -typedef float pr_float_t; -typedef float pr_vector_t[3]; -typedef uint32_t pr_entity_t; -typedef uint32_t pr_field_t; -typedef uint32_t pr_func_t; -typedef uint32_t pr_ptr_t; -typedef float pr_quaternion_t[4]; -typedef int32_t pr_int_t; -typedef uint32_t pr_uint_t; -typedef int16_t pr_short_t; -typedef double pr_double_t; -typedef int64_t pr_long_t; -typedef uint64_t pr_ulong_t; -typedef uint16_t pr_ushort_t; +typedef int32_t pr_string_t __attribute__((aligned(4))); +typedef float pr_float_t __attribute__((aligned(4))); +typedef float pr_vector_t[3] __attribute__((aligned(4))); +typedef uint32_t pr_entity_t __attribute__((aligned(4))); +typedef uint32_t pr_field_t __attribute__((aligned(4))); +typedef uint32_t pr_func_t __attribute__((aligned(4))); +typedef uint32_t pr_ptr_t __attribute__((aligned(4))); +typedef float pr_quaternion_t[4] __attribute__((aligned(4))); +typedef int32_t pr_int_t __attribute__((aligned(4))); +typedef uint32_t pr_uint_t __attribute__((aligned(4))); +typedef int16_t pr_short_t __attribute__((aligned(2))); +typedef double pr_double_t __attribute__((aligned(8))); +typedef int64_t pr_long_t __attribute__((aligned(8))); +typedef uint64_t pr_ulong_t __attribute__((aligned(8))); +typedef uint16_t pr_ushort_t __attribute__((aligned(2)));; #define PR_VEC_TYPE(t,n,s) \ typedef t n __attribute__ ((vector_size (s*sizeof (t)))) @@ -63,6 +63,7 @@ typedef enum { } etype_t; extern const pr_ushort_t pr_type_size[ev_type_count]; +extern const pr_ushort_t pr_type_alignment[ev_type_count]; extern const char * const pr_type_name[ev_type_count]; #define OFS_NULL 0 diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index 8fb79e851..c056297a9 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -41,6 +41,12 @@ VISIBLE const pr_ushort_t pr_type_size[ev_type_count] = { 0, // ev_invalid not a valid/simple type }; +#define EV_TYPE(type) (__alignof__ (pr_##type##_t) / __alignof__ (pr_int_t)), +VISIBLE const pr_ushort_t pr_type_alignment[ev_type_count] = { +#include "QF/progs/pr_type_names.h" + 0, // ev_invalid not a valid/simple type +}; + #define EV_TYPE(type) #type, VISIBLE const char * const pr_type_name[ev_type_count] = { #include "QF/progs/pr_type_names.h" From 5b97aa38973716999ed64df0d16a4a9c35ed6a0b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 21:22:18 +0900 Subject: [PATCH 146/360] [qfcc] Use index labels for the type arrays The one place that needed it most... constfold.c --- tools/qfcc/source/constfold.c | 480 +++++++++++++++++----------------- 1 file changed, 240 insertions(+), 240 deletions(-) diff --git a/tools/qfcc/source/constfold.c b/tools/qfcc/source/constfold.c index 8566e00b1..c09f82257 100644 --- a/tools/qfcc/source/constfold.c +++ b/tools/qfcc/source/constfold.c @@ -1053,288 +1053,288 @@ do_op_invalid (int op, expr_t *e, expr_t *e1, expr_t *e2) } static operation_t op_void[ev_type_count] = { - do_op_invalid, // ev_void - do_op_invalid, // ev_string - do_op_invalid, // ev_float - do_op_invalid, // ev_vector - do_op_invalid, // ev_entity - do_op_invalid, // ev_field - do_op_invalid, // ev_func - do_op_invalid, // ev_ptr - do_op_invalid, // ev_quaternion - do_op_invalid, // ev_int - do_op_invalid, // ev_uint - do_op_invalid, // ev_short - do_op_invalid, // ev_double - 0, // ev_long - 0, // ev_ulong - do_op_invalid, // ev_invalid + [ev_void] = do_op_invalid, + [ev_string] = do_op_invalid, + [ev_float] = do_op_invalid, + [ev_vector] = do_op_invalid, + [ev_entity] = do_op_invalid, + [ev_field] = do_op_invalid, + [ev_func] = do_op_invalid, + [ev_ptr] = do_op_invalid, + [ev_quaternion] = do_op_invalid, + [ev_int] = do_op_invalid, + [ev_uint] = do_op_invalid, + [ev_short] = do_op_invalid, + [ev_double] = do_op_invalid, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = do_op_invalid, }; static operation_t op_string[ev_type_count] = { - do_op_invalid, // ev_void - do_op_string, // ev_string - do_op_invalid, // ev_float - do_op_invalid, // ev_vector - do_op_invalid, // ev_entity - do_op_invalid, // ev_field - do_op_invalid, // ev_func - do_op_invalid, // ev_ptr - do_op_invalid, // ev_quaternion - do_op_invalid, // ev_int - do_op_invalid, // ev_uint - do_op_invalid, // ev_short - do_op_invalid, // ev_double - 0, // ev_long - 0, // ev_ulong - do_op_invalid, // ev_invalid + [ev_void] = do_op_invalid, + [ev_string] = do_op_string, + [ev_float] = do_op_invalid, + [ev_vector] = do_op_invalid, + [ev_entity] = do_op_invalid, + [ev_field] = do_op_invalid, + [ev_func] = do_op_invalid, + [ev_ptr] = do_op_invalid, + [ev_quaternion] = do_op_invalid, + [ev_int] = do_op_invalid, + [ev_uint] = do_op_invalid, + [ev_short] = do_op_invalid, + [ev_double] = do_op_invalid, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = do_op_invalid, }; static operation_t op_float[ev_type_count] = { - do_op_invalid, // ev_void - do_op_invalid, // ev_string - do_op_float, // ev_float - do_op_vector, // ev_vector - do_op_invalid, // ev_entity - do_op_invalid, // ev_field - do_op_invalid, // ev_func - do_op_invalid, // ev_ptr - do_op_quaternion, // ev_quaternion - do_op_float, // ev_int - do_op_float, // ev_uint - do_op_float, // ev_short - do_op_double, // ev_double - 0, // ev_long - 0, // ev_ulong - do_op_invalid, // ev_invalid + [ev_void] = do_op_invalid, + [ev_string] = do_op_invalid, + [ev_float] = do_op_float, + [ev_vector] = do_op_vector, + [ev_entity] = do_op_invalid, + [ev_field] = do_op_invalid, + [ev_func] = do_op_invalid, + [ev_ptr] = do_op_invalid, + [ev_quaternion] = do_op_quaternion, + [ev_int] = do_op_float, + [ev_uint] = do_op_float, + [ev_short] = do_op_float, + [ev_double] = do_op_double, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = do_op_invalid, }; static operation_t op_vector[ev_type_count] = { - do_op_invalid, // ev_void - do_op_invalid, // ev_string - do_op_vector, // ev_float - do_op_vector, // ev_vector - do_op_invalid, // ev_entity - do_op_invalid, // ev_field - do_op_invalid, // ev_func - do_op_invalid, // ev_ptr - do_op_invalid, // ev_quaternion - do_op_vector, // ev_int - do_op_vector, // ev_uint - do_op_vector, // ev_short - do_op_vector, // ev_double - 0, // ev_long - 0, // ev_ulong - do_op_invalid, // ev_invalid + [ev_void] = do_op_invalid, + [ev_string] = do_op_invalid, + [ev_float] = do_op_vector, + [ev_vector] = do_op_vector, + [ev_entity] = do_op_invalid, + [ev_field] = do_op_invalid, + [ev_func] = do_op_invalid, + [ev_ptr] = do_op_invalid, + [ev_quaternion] = do_op_invalid, + [ev_int] = do_op_vector, + [ev_uint] = do_op_vector, + [ev_short] = do_op_vector, + [ev_double] = do_op_vector, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = do_op_invalid, }; static operation_t op_entity[ev_type_count] = { - do_op_invalid, // ev_void - do_op_invalid, // ev_string - do_op_invalid, // ev_float - do_op_invalid, // ev_vector - do_op_entity, // ev_entity - do_op_entity, // ev_field - do_op_invalid, // ev_func - do_op_invalid, // ev_ptr - do_op_invalid, // ev_quaternion - do_op_invalid, // ev_int - do_op_invalid, // ev_uint - do_op_invalid, // ev_short - do_op_invalid, // ev_double - 0, // ev_long - 0, // ev_ulong - do_op_invalid, // ev_invalid + [ev_void] = do_op_invalid, + [ev_string] = do_op_invalid, + [ev_float] = do_op_invalid, + [ev_vector] = do_op_invalid, + [ev_entity] = do_op_entity, + [ev_field] = do_op_entity, + [ev_func] = do_op_invalid, + [ev_ptr] = do_op_invalid, + [ev_quaternion] = do_op_invalid, + [ev_int] = do_op_invalid, + [ev_uint] = do_op_invalid, + [ev_short] = do_op_invalid, + [ev_double] = do_op_invalid, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = do_op_invalid, }; static operation_t op_field[ev_type_count] = { - do_op_invalid, // ev_void - do_op_invalid, // ev_string - do_op_invalid, // ev_float - do_op_invalid, // ev_vector - do_op_invalid, // ev_entity - do_op_field, // ev_field - do_op_invalid, // ev_func - do_op_invalid, // ev_ptr - do_op_invalid, // ev_quaternion - do_op_invalid, // ev_int - do_op_invalid, // ev_uint - do_op_invalid, // ev_short - do_op_invalid, // ev_double - 0, // ev_long - 0, // ev_ulong - do_op_invalid, // ev_invalid + [ev_void] = do_op_invalid, + [ev_string] = do_op_invalid, + [ev_float] = do_op_invalid, + [ev_vector] = do_op_invalid, + [ev_entity] = do_op_invalid, + [ev_field] = do_op_field, + [ev_func] = do_op_invalid, + [ev_ptr] = do_op_invalid, + [ev_quaternion] = do_op_invalid, + [ev_int] = do_op_invalid, + [ev_uint] = do_op_invalid, + [ev_short] = do_op_invalid, + [ev_double] = do_op_invalid, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = do_op_invalid, }; static operation_t op_func[ev_type_count] = { - do_op_func, // ev_void - do_op_func, // ev_string - do_op_func, // ev_float - do_op_func, // ev_vector - do_op_func, // ev_entity - do_op_func, // ev_field - do_op_func, // ev_func - do_op_func, // ev_ptr - do_op_func, // ev_quaternion - do_op_func, // ev_int - do_op_func, // ev_uint - do_op_func, // ev_short - do_op_func, // ev_double - 0, // ev_long - 0, // ev_ulong - do_op_func, // ev_invalid + [ev_void] = do_op_func, + [ev_string] = do_op_func, + [ev_float] = do_op_func, + [ev_vector] = do_op_func, + [ev_entity] = do_op_func, + [ev_field] = do_op_func, + [ev_func] = do_op_func, + [ev_ptr] = do_op_func, + [ev_quaternion] = do_op_func, + [ev_int] = do_op_func, + [ev_uint] = do_op_func, + [ev_short] = do_op_func, + [ev_double] = do_op_func, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = do_op_func, }; static operation_t op_pointer[ev_type_count] = { - do_op_pointer, // ev_void - do_op_pointer, // ev_string - do_op_pointer, // ev_float - do_op_pointer, // ev_vector - do_op_pointer, // ev_entity - do_op_pointer, // ev_field - do_op_pointer, // ev_func - do_op_pointer, // ev_ptr - do_op_pointer, // ev_quaternion - do_op_pointer, // ev_int - do_op_pointer, // ev_uint - do_op_pointer, // ev_short - do_op_pointer, // ev_double - 0, // ev_long - 0, // ev_ulong - do_op_pointer, // ev_invalid + [ev_void] = do_op_pointer, + [ev_string] = do_op_pointer, + [ev_float] = do_op_pointer, + [ev_vector] = do_op_pointer, + [ev_entity] = do_op_pointer, + [ev_field] = do_op_pointer, + [ev_func] = do_op_pointer, + [ev_ptr] = do_op_pointer, + [ev_quaternion] = do_op_pointer, + [ev_int] = do_op_pointer, + [ev_uint] = do_op_pointer, + [ev_short] = do_op_pointer, + [ev_double] = do_op_pointer, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = do_op_pointer, }; static operation_t op_quaternion[ev_type_count] = { - do_op_invalid, // ev_void - do_op_invalid, // ev_string - do_op_quaternion, // ev_float - do_op_quatvect, // ev_vector - do_op_invalid, // ev_entity - do_op_invalid, // ev_field - do_op_invalid, // ev_func - do_op_invalid, // ev_ptr - do_op_quaternion, // ev_quaternion - do_op_quaternion, // ev_int - do_op_quaternion, // ev_uint - do_op_quaternion, // ev_short - do_op_quaternion, // ev_double - 0, // ev_long - 0, // ev_ulong - do_op_invalid, // ev_invalid + [ev_void] = do_op_invalid, + [ev_string] = do_op_invalid, + [ev_float] = do_op_quaternion, + [ev_vector] = do_op_quatvect, + [ev_entity] = do_op_invalid, + [ev_field] = do_op_invalid, + [ev_func] = do_op_invalid, + [ev_ptr] = do_op_invalid, + [ev_quaternion] = do_op_quaternion, + [ev_int] = do_op_quaternion, + [ev_uint] = do_op_quaternion, + [ev_short] = do_op_quaternion, + [ev_double] = do_op_quaternion, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = do_op_invalid, }; static operation_t op_int[ev_type_count] = { - do_op_invalid, // ev_void - do_op_invalid, // ev_string - do_op_float, // ev_float - do_op_vector, // ev_vector - do_op_invalid, // ev_entity - do_op_invalid, // ev_field - do_op_invalid, // ev_func - do_op_invalid, // ev_ptr - do_op_quaternion, // ev_quaternion - do_op_int, // ev_int - do_op_uint, // ev_uint - do_op_int, // ev_short - do_op_double, // ev_double - 0, // ev_long - 0, // ev_ulong - do_op_invalid, // ev_invalid + [ev_void] = do_op_invalid, + [ev_string] = do_op_invalid, + [ev_float] = do_op_float, + [ev_vector] = do_op_vector, + [ev_entity] = do_op_invalid, + [ev_field] = do_op_invalid, + [ev_func] = do_op_invalid, + [ev_ptr] = do_op_invalid, + [ev_quaternion] = do_op_quaternion, + [ev_int] = do_op_int, + [ev_uint] = do_op_uint, + [ev_short] = do_op_int, + [ev_double] = do_op_double, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = do_op_invalid, }; static operation_t op_uint[ev_type_count] = { - do_op_invalid, // ev_void - do_op_invalid, // ev_string - do_op_float, // ev_float - do_op_vector, // ev_vector - do_op_invalid, // ev_entity - do_op_invalid, // ev_field - do_op_invalid, // ev_func - do_op_invalid, // ev_ptr - do_op_quaternion, // ev_quaternion - do_op_uint, // ev_int - do_op_uint, // ev_uint - do_op_uint, // ev_short - do_op_double, // ev_double - 0, // ev_long - 0, // ev_ulong - do_op_invalid, // ev_invalid + [ev_void] = do_op_invalid, + [ev_string] = do_op_invalid, + [ev_float] = do_op_float, + [ev_vector] = do_op_vector, + [ev_entity] = do_op_invalid, + [ev_field] = do_op_invalid, + [ev_func] = do_op_invalid, + [ev_ptr] = do_op_invalid, + [ev_quaternion] = do_op_quaternion, + [ev_int] = do_op_uint, + [ev_uint] = do_op_uint, + [ev_short] = do_op_uint, + [ev_double] = do_op_double, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = do_op_invalid, }; static operation_t op_short[ev_type_count] = { - do_op_invalid, // ev_void - do_op_invalid, // ev_string - do_op_float, // ev_float - do_op_vector, // ev_vector - do_op_invalid, // ev_entity - do_op_invalid, // ev_field - do_op_invalid, // ev_func - do_op_invalid, // ev_ptr - do_op_quaternion, // ev_quaternion - do_op_int, // ev_int - do_op_uint, // ev_uint - do_op_short, // ev_short - do_op_double, // ev_double - 0, // ev_long - 0, // ev_ulong - do_op_invalid, // ev_invalid + [ev_void] = do_op_invalid, + [ev_string] = do_op_invalid, + [ev_float] = do_op_float, + [ev_vector] = do_op_vector, + [ev_entity] = do_op_invalid, + [ev_field] = do_op_invalid, + [ev_func] = do_op_invalid, + [ev_ptr] = do_op_invalid, + [ev_quaternion] = do_op_quaternion, + [ev_int] = do_op_int, + [ev_uint] = do_op_uint, + [ev_short] = do_op_short, + [ev_double] = do_op_double, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = do_op_invalid, }; static operation_t op_double[ev_type_count] = { - do_op_invalid, // ev_void - do_op_invalid, // ev_string - do_op_float, // ev_float - do_op_vector, // ev_vector - do_op_invalid, // ev_entity - do_op_invalid, // ev_field - do_op_invalid, // ev_func - do_op_invalid, // ev_ptr - do_op_quaternion, // ev_quaternion - do_op_int, // ev_int - do_op_uint, // ev_uint - do_op_short, // ev_short - do_op_double, // ev_double - 0, // ev_long - 0, // ev_ulong - do_op_invalid, // ev_invalid + [ev_void] = do_op_invalid, + [ev_string] = do_op_invalid, + [ev_float] = do_op_float, + [ev_vector] = do_op_vector, + [ev_entity] = do_op_invalid, + [ev_field] = do_op_invalid, + [ev_func] = do_op_invalid, + [ev_ptr] = do_op_invalid, + [ev_quaternion] = do_op_quaternion, + [ev_int] = do_op_int, + [ev_uint] = do_op_uint, + [ev_short] = do_op_short, + [ev_double] = do_op_double, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = do_op_invalid, }; static operation_t op_compound[ev_type_count] = { - do_op_invalid, // ev_void - do_op_invalid, // ev_string - do_op_compound, // ev_float - do_op_invalid, // ev_vector - do_op_invalid, // ev_entity - do_op_invalid, // ev_field - do_op_invalid, // ev_func - do_op_invalid, // ev_ptr - do_op_invalid, // ev_quaternion - do_op_compound, // ev_int - do_op_compound, // ev_uint - do_op_compound, // ev_short - do_op_compound, // ev_double - do_op_compound, // ev_long - do_op_compound, // ev_ulong - do_op_compound, // ev_invalid + [ev_void] = do_op_invalid, + [ev_string] = do_op_invalid, + [ev_float] = do_op_compound, + [ev_vector] = do_op_invalid, + [ev_entity] = do_op_invalid, + [ev_field] = do_op_invalid, + [ev_func] = do_op_invalid, + [ev_ptr] = do_op_invalid, + [ev_quaternion] = do_op_invalid, + [ev_int] = do_op_compound, + [ev_uint] = do_op_compound, + [ev_short] = do_op_compound, + [ev_double] = do_op_compound, + [ev_long] = do_op_compound, + [ev_ulong] = do_op_compound, + [ev_invalid] = do_op_compound, }; static operation_t *do_op[ev_type_count] = { - op_void, // ev_void - op_string, // ev_string - op_float, // ev_float - op_vector, // ev_vector - op_entity, // ev_entity - op_field, // ev_field - op_func, // ev_func - op_pointer, // ev_ptr - op_quaternion, // ev_quaternion - op_int, // ev_int - op_uint, // ev_uint - op_short, // ev_short - op_double, // ev_double - 0, // ev_long - 0, // ev_ulong - op_compound, // ev_invalid + [ev_void] = op_void, + [ev_string] = op_string, + [ev_float] = op_float, + [ev_vector] = op_vector, + [ev_entity] = op_entity, + [ev_field] = op_field, + [ev_func] = op_func, + [ev_ptr] = op_pointer, + [ev_quaternion] = op_quaternion, + [ev_int] = op_int, + [ev_uint] = op_uint, + [ev_short] = op_short, + [ev_double] = op_double, + [ev_long] = 0, + [ev_ulong] = 0, + [ev_invalid] = op_compound, }; static unaryop_t do_unary_op[ev_type_count]; From 6df79b2b06932a12c7f6a38396cc251ba31eb87e Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 21:42:53 +0900 Subject: [PATCH 147/360] [qfcc] Correct xdef structures and usage in test Attempting to add ev_ushort caused ptraliasenc to break, but that was because it was already broken: I had implemented the scan of the xdef table incorrectly, thus adding only 1 ev type resulted in the walked pointer being out of phase with its data due to it first passing over the type encodings (which is why adding long and ulong didn't cause any obvious trouble). --- tools/qfcc/source/type.c | 4 ++-- tools/qfcc/test/ptraliasenc.r | 16 +++++++++++----- 2 files changed, 13 insertions(+), 7 deletions(-) diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index c29c910bc..1e03bf19d 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -1210,7 +1210,7 @@ init_types (void) }; static struct_def_t type_encoding_struct[] = { {"types", &type_pointer}, - {"size", &type_int}, + {"size", &type_uint}, {0, 0} }; static struct_def_t xdef_struct[] = { @@ -1220,7 +1220,7 @@ init_types (void) }; static struct_def_t xdefs_struct[] = { {"xdefs", &type_xdef_pointer}, - {"num_xdefs", &type_pointer}, + {"num_xdefs", &type_uint}, {0, 0} }; static struct_def_t va_list_struct[] = { diff --git a/tools/qfcc/test/ptraliasenc.r b/tools/qfcc/test/ptraliasenc.r index 2f305617f..8e8a58e9c 100644 --- a/tools/qfcc/test/ptraliasenc.r +++ b/tools/qfcc/test/ptraliasenc.r @@ -10,16 +10,22 @@ typedef struct xdef_s { void *ofs; ///< 32-bit version of ddef_t.ofs } xdef_t; +typedef struct xdefs_s { + xdef_t *xdefs; + unsigned num_xdefs; +} xdefs_t; + void *PR_FindGlobal (string name) = #0; int main (void) { //FIXME need a simple way to get at a def's meta-data - xdef_t *xdefs = PR_FindGlobal (".xdefs"); - while (xdefs.ofs != &int32_ptr) { - xdefs++; + xdefs_t *xdefs = PR_FindGlobal (".xdefs"); + xdef_t *xdef = xdefs.xdefs; + while (xdef - xdefs.xdefs < xdefs.num_xdefs && xdef.ofs != &int32_ptr) { + xdef++; } - printf ("int32_ptr: %s\n", xdefs.type.encoding); - return xdefs.type.encoding != "{>^i}"; + printf ("int32_ptr: %s\n", xdef.type.encoding); + return xdef.type.encoding != "{>^i}"; } From 068c04ece64f14c9c88bcbe55044ac63d0b66de2 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 22:08:37 +0900 Subject: [PATCH 148/360] [gamecode] Add ev_ushort and partial support Really, only just enough to get everything compiling (which does include vkgen running correctly). --- include/QF/progs.h | 1 + include/QF/progs/pr_type_names.h | 1 + libs/gamecode/pr_debug.c | 15 +++++++++++++++ nq/source/sv_progs.c | 1 + qw/source/sv_progs.c | 1 + tools/qfcc/include/expr.h | 3 ++- tools/qfcc/source/dot_expr.c | 3 +++ tools/qfcc/source/expr.c | 3 +++ tools/qfcc/source/expr_bool.c | 1 + tools/qfcc/source/statements.c | 5 +++++ tools/qfcc/source/type.c | 8 ++++++++ 11 files changed, 41 insertions(+), 1 deletion(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index d2d32cf51..f9cf97b32 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1737,6 +1737,7 @@ typedef struct type_view_s { type_view_func double_view; type_view_func long_view; type_view_func ulong_view; + type_view_func ushort_view; type_view_func struct_view; type_view_func union_view; diff --git a/include/QF/progs/pr_type_names.h b/include/QF/progs/pr_type_names.h index 79dfaa4ff..5e9904b2a 100644 --- a/include/QF/progs/pr_type_names.h +++ b/include/QF/progs/pr_type_names.h @@ -45,5 +45,6 @@ EV_TYPE(short) // value is embedded in the opcode EV_TYPE(double) EV_TYPE(long) EV_TYPE(ulong) +EV_TYPE(ushort) #undef EV_TYPE diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 1f7e2a651..32f6a8dd9 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -149,6 +149,8 @@ static void pr_debug_long_view (qfot_type_t *type, pr_type_t *value, void *_data); static void pr_debug_ulong_view (qfot_type_t *type, pr_type_t *value, void *_data); +static void pr_debug_ushort_view (qfot_type_t *type, pr_type_t *value, + void *_data); static void pr_debug_struct_view (qfot_type_t *type, pr_type_t *value, void *_data); static void pr_debug_union_view (qfot_type_t *type, pr_type_t *value, @@ -176,6 +178,7 @@ static type_view_t raw_type_view = { pr_debug_double_view, pr_debug_long_view, pr_debug_ulong_view, + pr_debug_ushort_view, pr_debug_struct_view, pr_debug_union_view, pr_debug_enum_view, @@ -1074,6 +1077,9 @@ value_string (pr_debug_data_t *data, qfot_type_t *type, pr_type_t *value) case ev_ulong: raw_type_view.ulong_view (type, value, data); break; + case ev_ushort: + raw_type_view.ushort_view (type, value, data); + break; case ev_invalid: case ev_type_count: dstring_appendstr (data->dstr, ""); @@ -1395,6 +1401,15 @@ pr_debug_ulong_view (qfot_type_t *type, pr_type_t *value, void *_data) dasprintf (dstr, "%" PRIu64, *(uint64_t *)value); } +static void +pr_debug_ushort_view (qfot_type_t *type, pr_type_t *value, void *_data) +{ + __auto_type data = (pr_debug_data_t *) _data; + dstring_t *dstr = data->dstr; + + dasprintf (dstr, "%04x", (pr_ushort_t)value->int_var); +} + static void pr_dump_struct (qfot_type_t *type, pr_type_t *value, void *_data, const char *struct_type) diff --git a/nq/source/sv_progs.c b/nq/source/sv_progs.c index 6da6199f2..a6cc1cbc7 100644 --- a/nq/source/sv_progs.c +++ b/nq/source/sv_progs.c @@ -339,6 +339,7 @@ set_address (sv_def_t *def, void *address) switch (def->type) { case ev_void: case ev_short: + case ev_ushort: case ev_invalid: case ev_type_count: break; diff --git a/qw/source/sv_progs.c b/qw/source/sv_progs.c index d0636718c..8c8809c38 100644 --- a/qw/source/sv_progs.c +++ b/qw/source/sv_progs.c @@ -372,6 +372,7 @@ set_address (sv_def_t *def, void *address) switch (def->type) { case ev_void: case ev_short: + case ev_ushort: case ev_invalid: case ev_type_count: break; diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index f75fd79ba..9d220b804 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -203,7 +203,8 @@ typedef struct ex_value_s { float quaternion_val[4]; ///< quaternion constant int int_val; ///< int constant unsigned uint_val; ///< unsigned int constant - short short_val; ///< short constant + int16_t short_val; ///< short constant + uint16_t ushort_val; ///< unsigned short constant } v; } ex_value_t; diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index 84d0acc3f..0074aa328 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -593,6 +593,9 @@ print_value (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) case ev_short: label = va (0, "s %d", e->e.value->v.short_val); break; + case ev_ushort: + label = va (0, "us %d", e->e.value->v.ushort_val); + break; case ev_void: label = ""; break; diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 19af1437f..d75d45ab5 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1712,6 +1712,7 @@ unary_expr (int op, expr_t *e) return new_vector_expr (q); case ev_long: case ev_ulong: + case ev_ushort: internal_error (e, "long not implemented"); case ev_int: return new_int_expr (-expr_int (e)); @@ -1813,6 +1814,7 @@ unary_expr (int op, expr_t *e) return new_int_expr (!QuatIsZero (expr_quaternion (e))); case ev_long: case ev_ulong: + case ev_ushort: internal_error (e, "long not implemented"); case ev_int: return new_int_expr (!expr_int (e)); @@ -1887,6 +1889,7 @@ unary_expr (int op, expr_t *e) return new_vector_expr (q); case ev_long: case ev_ulong: + case ev_ushort: internal_error (e, "long not implemented"); case ev_int: return new_int_expr (~expr_int (e)); diff --git a/tools/qfcc/source/expr_bool.c b/tools/qfcc/source/expr_bool.c index 5055d38d5..5894e1bad 100644 --- a/tools/qfcc/source/expr_bool.c +++ b/tools/qfcc/source/expr_bool.c @@ -96,6 +96,7 @@ test_expr (expr_t *e) break; case ev_long: case ev_ulong: + case ev_ushort: internal_error (e, "long not implemented"); case ev_uint: case ev_int: diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 8e6b01232..9428e64d2 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -168,6 +168,8 @@ operand_string (operand_t *op) return va (0, "ulong %"PRIu64, op->value->v.ulong_val); case ev_short: return va (0, "short %d", op->value->v.short_val); + case ev_ushort: + return va (0, "ushort %d", op->value->v.ushort_val); case ev_void: return "(void)"; case ev_invalid: @@ -252,6 +254,9 @@ _print_operand (operand_t *op) case ev_short: printf ("%d", op->value->v.short_val); break; + case ev_ushort: + printf ("%d", op->value->v.ushort_val); + break; case ev_void: case ev_invalid: case ev_type_count: diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index 1e03bf19d..fed6f0e1d 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -110,6 +110,7 @@ type_t *ev_types[ev_type_count] = { &type_uint, &type_short, &type_double, + 0, 0, 0, &type_invalid, }; @@ -191,6 +192,7 @@ free_type (type_t *type) case ev_long: case ev_ulong: case ev_short: + case ev_ushort: case ev_double: break; case ev_field: @@ -233,6 +235,7 @@ copy_chain (type_t *type, type_t *append) case ev_long: case ev_ulong: case ev_short: + case ev_ushort: case ev_double: internal_error (0, "copy basic type"); case ev_field: @@ -286,6 +289,7 @@ append_type (type_t *type, type_t *new) case ev_long: case ev_ulong: case ev_short: + case ev_ushort: case ev_double: internal_error (0, "append to basic type"); case ev_field: @@ -665,6 +669,7 @@ print_type_str (dstring_t *str, const type_t *type) case ev_long: case ev_ulong: case ev_short: + case ev_ushort: case ev_double: dasprintf (str, " %s", pr_type_name[type->type]); return; @@ -837,6 +842,9 @@ encode_type (dstring_t *encoding, const type_t *type) case ev_short: dasprintf (encoding, "s"); return; + case ev_ushort: + dasprintf (encoding, "S"); + return; case ev_invalid: case ev_type_count: break; From 57fe6690991ac2e542c5c40b86b080291a133e5f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 22:34:52 +0900 Subject: [PATCH 149/360] [qfcc] Shorten type_function and type_pointer names To type_func and type_ptr to match the ev type names. --- tools/qfcc/source/class.c | 57 +++++++++++++++++----------------- tools/qfcc/source/expr.c | 2 +- tools/qfcc/source/function.c | 2 +- tools/qfcc/source/method.c | 6 ++-- tools/qfcc/source/qc-lex.l | 2 +- tools/qfcc/source/statements.c | 4 +-- tools/qfcc/source/type.c | 26 +++++++--------- tools/qfcc/source/value.c | 4 +-- 8 files changed, 50 insertions(+), 53 deletions(-) diff --git a/tools/qfcc/source/class.c b/tools/qfcc/source/class.c index b821135a7..4f9b2e8fe 100644 --- a/tools/qfcc/source/class.c +++ b/tools/qfcc/source/class.c @@ -123,9 +123,9 @@ static struct_def_t method_desc_struct[] = { static struct_def_t category_struct[] = { {"category_name", &type_string}, {"class_name", &type_string}, - {"instance_methods", &type_pointer}, - {"class_methods", &type_pointer}, - {"protocols", &type_pointer}, + {"instance_methods", &type_ptr}, + {"class_methods", &type_ptr}, + {"protocols", &type_ptr}, {0, 0} }; @@ -146,7 +146,7 @@ static struct_def_t module_struct[] = { {"version", &type_int}, {"size", &type_int}, {"name", &type_string}, - {"symtab", &type_pointer}, + {"symtab", &type_ptr}, {0, 0} }; @@ -157,22 +157,22 @@ static struct_def_t class_struct[] = { {"version", &type_int}, {"info", &type_int}, {"instance_size", &type_int}, - {"ivars", &type_pointer}, - {"methods", &type_pointer}, - {"dtable", &type_pointer}, - {"subclass_list", &type_pointer}, - {"sibling_class", &type_pointer}, - {"protocols", &type_pointer}, - {"gc_object_type", &type_pointer}, + {"ivars", &type_ptr}, + {"methods", &type_ptr}, + {"dtable", &type_ptr}, + {"subclass_list", &type_ptr}, + {"sibling_class", &type_ptr}, + {"protocols", &type_ptr}, + {"gc_object_type", &type_ptr}, {0, 0} }; static struct_def_t protocol_struct[] = { {"class_pointer", &type_Class}, {"protocol_name", &type_string}, - {"protocol_list", &type_pointer}, - {"instance_methods", &type_pointer}, - {"class_methods", &type_pointer}, + {"protocol_list", &type_ptr}, + {"instance_methods", &type_ptr}, + {"class_methods", &type_ptr}, {0, 0} }; @@ -257,8 +257,7 @@ emit_static_instances (const char *classname) for (static_instance_t **inst = data.instances; *inst; inst++) { data.num_instances++; } - instances_struct[1].type = array_type (&type_pointer, - data.num_instances + 1); + instances_struct[1].type = array_type (&type_ptr, data.num_instances + 1); instances_def = emit_structure (va (0, "_OBJ_STATIC_INSTANCES_%s", classname), 's', instances_struct, 0, &data, @@ -298,7 +297,7 @@ emit_static_instances_list (void) free (classes); // +1 for terminating null - instance_lists_type = array_type (&type_pointer, num_classes + 1); + instance_lists_type = array_type (&type_ptr, num_classes + 1); instance_lists_sym = make_symbol ("_OBJ_STATIC_INSTANCES", instance_lists_type, pr.far_data, sc_static); @@ -878,7 +877,7 @@ emit_class_ref (const char *class_name) def_t *name_def; ref_sym = make_symbol (va (0, ".obj_class_ref_%s", class_name), - &type_pointer, pr.far_data, sc_static); + &type_ptr, pr.far_data, sc_static); if (!ref_sym->table) symtab_addsymbol (pr.symtab, ref_sym); ref_def = ref_sym->s.def; @@ -886,7 +885,7 @@ emit_class_ref (const char *class_name) return; ref_def->initialized = ref_def->constant = ref_def->nosave = 1; name_sym = make_symbol (va (0, ".obj_class_name_%s", class_name), - &type_pointer, pr.far_data, sc_extern); + &type_ptr, pr.far_data, sc_extern); if (!name_sym->table) symtab_addsymbol (pr.symtab, name_sym); name_def = name_sym->s.def; @@ -902,7 +901,7 @@ emit_class_name (const char *class_name) def_t *name_def; name_sym = make_symbol (va (0, ".obj_class_name_%s", class_name), - &type_pointer, pr.far_data, sc_global); + &type_ptr, pr.far_data, sc_global); if (!name_sym->table) symtab_addsymbol (pr.symtab, name_sym); name_def = name_sym->s.def; @@ -923,7 +922,7 @@ emit_category_ref (const char *class_name, const char *category_name) ref_sym = make_symbol (va (0, ".obj_category_ref_%s_%s", class_name, category_name), - &type_pointer, pr.far_data, sc_static); + &type_ptr, pr.far_data, sc_static); if (!ref_sym->table) symtab_addsymbol (pr.symtab, ref_sym); ref_def = ref_sym->s.def; @@ -933,7 +932,7 @@ emit_category_ref (const char *class_name, const char *category_name) ref_def->nosave = 1; name_sym = make_symbol (va (0, ".obj_category_name_%s_%s", class_name, category_name), - &type_pointer, pr.far_data, sc_extern); + &type_ptr, pr.far_data, sc_extern); if (!name_sym->table) symtab_addsymbol (pr.symtab, name_sym); name_def = name_sym->s.def; @@ -950,7 +949,7 @@ emit_category_name (const char *class_name, const char *category_name) name_sym = make_symbol (va (0, ".obj_category_name_%s_%s", class_name, category_name), - &type_pointer, pr.far_data, sc_global); + &type_ptr, pr.far_data, sc_global); if (!name_sym->table) symtab_addsymbol (pr.symtab, name_sym); name_def = name_sym->s.def; @@ -1526,7 +1525,7 @@ class_finish_module (void) if (!data.refs && !data.cls_def_cnt && !data.cat_def_cnt && !data.instances_list) return; - symtab_struct[4].type = array_type (&type_pointer, + symtab_struct[4].type = array_type (&type_ptr, data.cls_def_cnt + data.cat_def_cnt + 1); @@ -1553,7 +1552,7 @@ class_finish_module (void) sc_extern); } - init_sym = new_symbol_type (".ctor", &type_function); + init_sym = new_symbol_type (".ctor", &type_func); init_sym = function_symbol (init_sym, 0, 1); module_expr = address_expr (new_symbol_expr (module_sym), 0, 0); @@ -1776,15 +1775,15 @@ def_t * emit_protocol_list (protocollist_t *protocols, const char *name) { static struct_def_t proto_list_struct[] = { - {"next", &type_pointer, emit_protocol_next}, - {"count", &type_int, emit_protocol_count}, - {"list", 0, emit_protocol_list_item}, + {"next", &type_ptr, emit_protocol_next}, + {"count", &type_int, emit_protocol_count}, + {"list", 0, emit_protocol_list_item}, {0, 0}, }; if (!protocols) return 0; - proto_list_struct[2].type = array_type (&type_pointer, protocols->count); + proto_list_struct[2].type = array_type (&type_ptr, protocols->count); return emit_structure (va (0, "_OBJ_PROTOCOLS_%s", name), 's', proto_list_struct, 0, protocols, 0, sc_static); } diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index d75d45ab5..fe9c2f03f 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -2789,7 +2789,7 @@ think_expr (symbol_t *think_sym) && sym->type->t.fldptr.type->type == ev_func) { think_sym->type = sym->type->t.fldptr.type; } else { - think_sym->type = &type_function; + think_sym->type = &type_func; } think_sym = function_symbol (think_sym, 0, 1); make_function (think_sym, 0, current_symtab->space, current_storage); diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index 08a397651..b20d38cf5 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -590,7 +590,7 @@ begin_function (symbol_t *sym, const char *nicename, symtab_t *parent, if (sym->sy_type != sy_func) { error (0, "%s is not a function", sym->name); - sym = new_symbol_type (sym->name, &type_function); + sym = new_symbol_type (sym->name, &type_func); sym = function_symbol (sym, 1, 1); } if (sym->s.func && sym->s.func->def && sym->s.func->def->initialized) { diff --git a/tools/qfcc/source/method.c b/tools/qfcc/source/method.c index 67df1d3fb..6fa038370 100644 --- a/tools/qfcc/source/method.c +++ b/tools/qfcc/source/method.c @@ -585,9 +585,9 @@ def_t * emit_methods (methodlist_t *methods, const char *name, int instance) { static struct_def_t methods_struct[] = { - {"method_next", &type_pointer, emit_methods_next}, - {"method_count", &type_int, emit_methods_count}, - {"method_list", 0, emit_methods_list_item}, + {"method_next", &type_ptr, emit_methods_next}, + {"method_count", &type_int, emit_methods_count}, + {"method_list", 0, emit_methods_list_item}, {0, 0} }; const char *type = instance ? "INSTANCE" : "CLASS"; diff --git a/tools/qfcc/source/qc-lex.l b/tools/qfcc/source/qc-lex.l index c53965993..ed742fc52 100644 --- a/tools/qfcc/source/qc-lex.l +++ b/tools/qfcc/source/qc-lex.l @@ -379,7 +379,7 @@ static keyword_t qf_keywords[] = { {"int", TYPE, &type_int }, {"unsigned", TYPE, &type_int },//FIXME - {"@function", TYPE, &type_function }, + {"@function", TYPE, &type_func }, {"@args", ARGS, 0 }, {"@va_list", TYPE, &type_va_list }, {"@param", TYPE, &type_param }, diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 9428e64d2..d5b385f14 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -955,7 +955,7 @@ dereference_dst: s = new_statement (st_expr, "&", dst_expr); s->opa = dst; s->opb = ofs; - s->opc = temp_operand (&type_pointer, dst_expr); + s->opc = temp_operand (&type_ptr, dst_expr); sblock_add_statement (sblock, s); dst = s->opc; ofs = 0; @@ -1128,7 +1128,7 @@ lea_statement (operand_t *pointer, operand_t *offset, expr_t *e) statement_t *s = new_statement (st_expr, "&", e); s->opa = pointer; s->opb = offset; - s->opc = temp_operand (&type_pointer, e); + s->opc = temp_operand (&type_ptr, e); return s; } diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index fed6f0e1d..77e0a1e54 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -69,11 +69,9 @@ type_t type_vector = { ev_vector, "vector", 1 }; type_t type_entity = { ev_entity, "entity", 1 }; type_t type_field = {ev_field, "field", 1, ty_basic, {{&type_void}} }; -// type_function is a void() function used for state defs -type_t type_function = { ev_func, "function", 1, ty_basic, - {{&type_void}} }; -type_t type_pointer = { ev_ptr, "pointer", 1, ty_basic, - {{&type_void}} }; +// type_func is a void() function used for state defs +type_t type_func = { ev_func, "func", 1, ty_basic, {{&type_void}} }; +type_t type_ptr = { ev_ptr, "pointer", 1, ty_basic, {{&type_void}} }; type_t type_quaternion = { ev_quaternion, "quaternion", 4 }; type_t type_int = { ev_int, "int", 1 }; type_t type_uint = { ev_uint, "uint", 1 }; @@ -1141,8 +1139,8 @@ chain_basic_types (void) type_entity.t.symtab = pr.entity_fields; chain_type (&type_entity); chain_type (&type_field); - chain_type (&type_function); - chain_type (&type_pointer); + chain_type (&type_func); + chain_type (&type_ptr); chain_type (&type_floatfield); if (!options.traditional) { chain_type (&type_quaternion); @@ -1180,8 +1178,8 @@ init_types (void) {"float_val", &type_float}, {"entity_val", &type_entity}, {"field_val", &type_field}, - {"func_val", &type_function}, - {"pointer_val", &type_pointer}, + {"func_val", &type_func}, + {"pointer_val", &type_ptr}, {"vector_val", &type_vector}, {"int_val", &type_int}, {"uint_val", &type_uint}, @@ -1197,8 +1195,8 @@ init_types (void) {"vector_val", &type_vector}, {"entity_val", &type_entity}, {"field_val", &type_field}, - {"func_val", &type_function}, - {"pointer_val", &type_pointer}, + {"func_val", &type_func}, + {"pointer_val", &type_ptr}, {"int_val", &type_int}, {"uint_val", &type_uint}, {"quaternion_val", &type_quaternion}, @@ -1217,13 +1215,13 @@ init_types (void) {0, 0} }; static struct_def_t type_encoding_struct[] = { - {"types", &type_pointer}, + {"types", &type_ptr}, {"size", &type_uint}, {0, 0} }; static struct_def_t xdef_struct[] = { - {"types", &type_pointer}, - {"offset", &type_pointer}, + {"types", &type_ptr}, + {"offset", &type_ptr}, {0, 0} }; static struct_def_t xdefs_struct[] = { diff --git a/tools/qfcc/source/value.c b/tools/qfcc/source/value.c index 7cdc55782..f96e5c720 100644 --- a/tools/qfcc/source/value.c +++ b/tools/qfcc/source/value.c @@ -505,11 +505,11 @@ emit_value (ex_value_t *value, def_t *def) break; case ev_func: tab = func_imm_defs; - type = &type_function; + type = &type_func; break; case ev_ptr: tab = pointer_imm_defs; - type = &type_pointer; + type = &type_ptr; break; case ev_int: case ev_uint: From 8d20997b2b2b3727e3bff65d6de95eeac66d046b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 22:58:26 +0900 Subject: [PATCH 150/360] [gamecode] Move pr_void_t to pr_comp.h I think I had decided to put it there but forgot before committing the size change, but I wound up needing it for qfcc. --- include/QF/progs/pr_comp.h | 2 ++ libs/gamecode/pr_opcode.c | 2 -- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 5d66fc323..22d7e0dc8 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -534,6 +534,8 @@ typedef union pr_type_u { pr_uint_t uint_var; } pr_type_t; +typedef pr_type_t pr_void_t; // so size of void is 1 + typedef struct pr_va_list_s { pr_int_t count; pr_ptr_t list; // pr_type_t diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index c056297a9..799066c7c 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -33,8 +33,6 @@ #include "QF/progs.h" -typedef pr_type_t pr_void_t; // so size of void is 1 - #define EV_TYPE(type) (sizeof (pr_##type##_t) / sizeof (pr_int_t)), VISIBLE const pr_ushort_t pr_type_size[ev_type_count] = { #include "QF/progs/pr_type_names.h" From 17add5e00f9b091fb89c747e4fbb2885db2c8afc Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 18 Jan 2022 22:59:53 +0900 Subject: [PATCH 151/360] [qfcc] Use pr_type_names to create basic type defs This takes care of the type structs and the ev_* to type map. --- tools/qfcc/include/type.h | 16 +++----------- tools/qfcc/source/type.c | 44 +++++++++++++-------------------------- 2 files changed, 17 insertions(+), 43 deletions(-) diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h index 87ca80966..a28d729c6 100644 --- a/tools/qfcc/include/type.h +++ b/tools/qfcc/include/type.h @@ -96,21 +96,11 @@ typedef struct { unsigned nosave:1; } specifier_t; +#define EV_TYPE(type) extern type_t type_##type; +#include "QF/progs/pr_type_names.h" + extern type_t type_invalid; -extern type_t type_void; -extern type_t type_string; -extern type_t type_double; -extern type_t type_float; -extern type_t type_vector; -extern type_t type_entity; -extern type_t type_field; -extern type_t type_function; -extern type_t type_pointer; extern type_t type_floatfield; -extern type_t type_quaternion; -extern type_t type_int; -extern type_t type_uint; -extern type_t type_short; extern type_t *type_nil; // for passing nil into ... extern type_t *type_default; // default type (float or int) diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index 77e0a1e54..dcdde6c7b 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -60,23 +60,19 @@ #include "tools/qfcc/include/symtab.h" #include "tools/qfcc/include/type.h" -// simple types. function types are dynamically allocated -type_t type_invalid = { ev_invalid, "invalid" }; -type_t type_void = { ev_void, "void", 1 }; -type_t type_string = { ev_string, "string", 1 }; -type_t type_float = { ev_float, "float", 1 }; -type_t type_vector = { ev_vector, "vector", 1 }; -type_t type_entity = { ev_entity, "entity", 1 }; -type_t type_field = {ev_field, "field", 1, ty_basic, {{&type_void}} }; +#define EV_TYPE(t) \ + type_t type_##t = { \ + .type = ev_##t, \ + .name = #t, \ + .alignment = __alignof__(pr_##t##_t) / __alignof__ (pr_int_t), \ + .meta = ty_basic, \ + {{ __builtin_choose_expr (ev_##t == ev_field \ + || ev_##t == ev_func \ + || ev_##t == ev_ptr, &type_void, 0 ) }}, \ + }; +#include "QF/progs/pr_type_names.h" -// type_func is a void() function used for state defs -type_t type_func = { ev_func, "func", 1, ty_basic, {{&type_void}} }; -type_t type_ptr = { ev_ptr, "pointer", 1, ty_basic, {{&type_void}} }; -type_t type_quaternion = { ev_quaternion, "quaternion", 4 }; -type_t type_int = { ev_int, "int", 1 }; -type_t type_uint = { ev_uint, "uint", 1 }; -type_t type_short = { ev_short, "short", 1 }; -type_t type_double = { ev_double, "double", 2 }; +type_t type_invalid = { ev_invalid, "invalid" }; type_t *type_nil; type_t *type_default; @@ -94,21 +90,9 @@ type_t type_xdefs = { ev_invalid, "@xdefs", 0, ty_struct }; type_t type_floatfield = { ev_field, ".float", 1, ty_basic, {{&type_float}} }; +#define EV_TYPE(type) &type_##type, type_t *ev_types[ev_type_count] = { - &type_void, - &type_string, - &type_float, - &type_vector, - &type_entity, - &type_field, - &type_function, - &type_pointer, - &type_quaternion, - &type_int, - &type_uint, - &type_short, - &type_double, - 0, 0, 0, +#include "QF/progs/pr_type_names.h" &type_invalid, }; From 380cb3ba7f8dd49d30f55af938ebd9730028b8f9 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 19 Jan 2022 10:52:07 +0900 Subject: [PATCH 152/360] [qfcc] Clean up the type tables for binary expressions More index labels and remove the null entries since they're not needed with the labels. --- tools/qfcc/source/expr_binary.c | 240 ++++++++++---------------------- 1 file changed, 71 insertions(+), 169 deletions(-) diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index dfd02b5c8..f551cafc7 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -526,211 +526,113 @@ static expr_type_t double_double[] = { }; static expr_type_t *string_x[ev_type_count] = { - 0, // ev_void - string_string, - 0, // ev_float - 0, // ev_vector - 0, // ev_entity - 0, // ev_field - 0, // ev_func - 0, // ev_ptr - 0, // ev_quaternion - 0, // ev_int - 0, // ev_uint - 0, // ev_short - 0, // ev_double + [ev_string] = string_string, }; static expr_type_t *float_x[ev_type_count] = { - 0, // ev_void - 0, // ev_string - float_float, - float_vector, - 0, // ev_entity - 0, // ev_field - 0, // ev_func - 0, // ev_ptr - float_quat, - float_int, - float_uint, - float_short, - float_double, + [ev_float] = float_float, + [ev_vector] = float_vector, + [ev_quaternion] = float_quat, + [ev_int] = float_int, + [ev_uint] = float_uint, + [ev_short] = float_short, + [ev_double] = float_double, }; static expr_type_t *vector_x[ev_type_count] = { - 0, // ev_void - 0, // ev_string - vector_float, - vector_vector, - 0, // ev_entity - 0, // ev_field - 0, // ev_func - 0, // ev_ptr - 0, // ev_quaternion - vector_int, - vector_uint, - vector_short, - vector_double, + [ev_float] = vector_float, + [ev_vector] = vector_vector, + [ev_int] = vector_int, + [ev_uint] = vector_uint, + [ev_short] = vector_short, + [ev_double] = vector_double, }; static expr_type_t *entity_x[ev_type_count] = { - 0, // ev_void - 0, // ev_string - 0, // ev_float - 0, // ev_vector - entity_entity, // ev_entity - 0, // ev_field - 0, // ev_func - 0, // ev_ptr - 0, // ev_quaternion - 0, // ev_int - 0, // ev_uint - 0, // ev_short - 0, // ev_double + [ev_entity] = entity_entity, }; static expr_type_t *field_x[ev_type_count] = { - 0, // ev_void - 0, // ev_string - 0, // ev_float - 0, // ev_vector - 0, // ev_entity - field_field, // ev_field - 0, // ev_func - 0, // ev_ptr - 0, // ev_quaternion - 0, // ev_int - 0, // ev_uint - 0, // ev_short - 0, // ev_double + [ev_field] = field_field, }; static expr_type_t *func_x[ev_type_count] = { - 0, // ev_void - 0, // ev_string - 0, // ev_float - 0, // ev_vector - 0, // ev_entity - 0, // ev_field - func_func, // ev_func - 0, // ev_ptr - 0, // ev_quaternion - 0, // ev_int - 0, // ev_uint - 0, // ev_short - 0, // ev_double + [ev_func] = func_func, }; static expr_type_t *pointer_x[ev_type_count] = { - 0, // ev_void - 0, // ev_string - 0, // ev_float - 0, // ev_vector - 0, // ev_entity - 0, // ev_field - 0, // ev_func - pointer_pointer, - 0, // ev_quaternion - pointer_int, - pointer_uint, - pointer_short, - 0, // ev_double + [ev_ptr] = pointer_pointer, + [ev_int] = pointer_int, + [ev_uint] = pointer_uint, + [ev_short] = pointer_short, }; static expr_type_t *quat_x[ev_type_count] = { - 0, // ev_void - 0, // ev_string - quat_float, - quat_vector, - 0, // ev_entity - 0, // ev_field - 0, // ev_func - 0, // ev_ptr - quat_quat, - quat_int, - quat_uint, - quat_short, - quat_double, + [ev_float] = quat_float, + [ev_vector] = quat_vector, + [ev_quaternion] = quat_quat, + [ev_int] = quat_int, + [ev_uint] = quat_uint, + [ev_short] = quat_short, + [ev_double] = quat_double, }; static expr_type_t *int_x[ev_type_count] = { - 0, // ev_void - 0, // ev_string - int_float, - int_vector, - 0, // ev_entity - 0, // ev_field - 0, // ev_func - int_pointer, - int_quat, - int_int, - int_uint, - int_short, - int_double, + [ev_float] = int_float, + [ev_vector] = int_vector, + [ev_ptr] = int_pointer, + [ev_quaternion] = int_quat, + [ev_int] = int_int, + [ev_uint] = int_uint, + [ev_short] = int_short, + [ev_double] = int_double, }; static expr_type_t *uint_x[ev_type_count] = { - 0, // ev_void - 0, // ev_string - uint_float, - uint_vector, - 0, // ev_entity - 0, // ev_field - 0, // ev_func - uint_pointer, - uint_quat, - uint_int, - uint_uint, - uint_short, - uint_double, + [ev_float] = uint_float, + [ev_vector] = uint_vector, + [ev_ptr] = uint_pointer, + [ev_quaternion] = uint_quat, + [ev_int] = uint_int, + [ev_uint] = uint_uint, + [ev_short] = uint_short, + [ev_double] = uint_double, }; static expr_type_t *short_x[ev_type_count] = { - 0, // ev_void - 0, // ev_string - short_float, - short_vector, - 0, // ev_entity - 0, // ev_field - 0, // ev_func - short_pointer, - short_quat, - short_int, - short_uint, - short_short, - short_double, + [ev_float] = short_float, + [ev_vector] = short_vector, + [ev_ptr] = short_pointer, + [ev_quaternion] = short_quat, + [ev_int] = short_int, + [ev_uint] = short_uint, + [ev_short] = short_short, + [ev_double] = short_double, }; static expr_type_t *double_x[ev_type_count] = { - 0, // ev_void - 0, // ev_string - double_float, - double_vector, - 0, // ev_entity - 0, // ev_field - 0, // ev_func - 0, // ev_ptr - double_quat, - double_int, - double_uint, - double_short, - double_double, + [ev_float] = double_float, + [ev_vector] = double_vector, + [ev_quaternion] = double_quat, + [ev_int] = double_int, + [ev_uint] = double_uint, + [ev_short] = double_short, + [ev_double] = double_double, }; static expr_type_t **binary_expr_types[ev_type_count] = { - 0, // ev_void - string_x, - float_x, - vector_x, - entity_x, - field_x, - func_x, - pointer_x, - quat_x, - int_x, - uint_x, - short_x, - double_x + [ev_string] = string_x, + [ev_float] = float_x, + [ev_vector] = vector_x, + [ev_entity] = entity_x, + [ev_field] = field_x, + [ev_func] = func_x, + [ev_ptr] = pointer_x, + [ev_quaternion] = quat_x, + [ev_int] = int_x, + [ev_uint] = uint_x, + [ev_short] = short_x, + [ev_double] = double_x }; static expr_t * From e11fa77a3475b4d43ef19160898c11f7e56a0029 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 19 Jan 2022 17:48:46 +0900 Subject: [PATCH 153/360] [qfcc] Use pr_type_names to generate is_TYPE This means basic types will always have a check function automatically. --- tools/qfcc/include/type.h | 17 +---- tools/qfcc/source/class.c | 12 +-- tools/qfcc/source/emit.c | 3 +- tools/qfcc/source/expr.c | 11 ++- tools/qfcc/source/expr_assign.c | 2 +- tools/qfcc/source/expr_binary.c | 8 +- tools/qfcc/source/method.c | 2 +- tools/qfcc/source/type.c | 125 +++----------------------------- 8 files changed, 32 insertions(+), 148 deletions(-) diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h index a28d729c6..d6d93ede8 100644 --- a/tools/qfcc/include/type.h +++ b/tools/qfcc/include/type.h @@ -149,26 +149,17 @@ void dump_dot_type (void *t, const char *filename); const char *encode_params (const type_t *type); void encode_type (struct dstring_s *encoding, const type_t *type); const char *type_get_encoding (const type_t *type); -int is_void (const type_t *type) __attribute__((pure)); + +#define EV_TYPE(t) int is_##t (const type_t *type) __attribute__((pure)); +#include "QF/progs/pr_type_names.h" + int is_enum (const type_t *type) __attribute__((pure)); -int is_int (const type_t *type) __attribute__((pure)); -int is_uint (const type_t *type) __attribute__((pure)); -int is_short (const type_t *type) __attribute__((pure)); int is_integral (const type_t *type) __attribute__((pure)); -int is_double (const type_t *type) __attribute__((pure)); -int is_float (const type_t *type) __attribute__((pure)); int is_scalar (const type_t *type) __attribute__((pure)); -int is_vector (const type_t *type) __attribute__((pure)); -int is_quaternion (const type_t *type) __attribute__((pure)); int is_math (const type_t *type) __attribute__((pure)); -int is_pointer (const type_t *type) __attribute__((pure)); -int is_field (const type_t *type) __attribute__((pure)); -int is_entity (const type_t *type) __attribute__((pure)); int is_struct (const type_t *type) __attribute__((pure)); int is_array (const type_t *type) __attribute__((pure)); int is_structural (const type_t *type) __attribute__((pure)); -int is_func (const type_t *type) __attribute__((pure)); -int is_string (const type_t *type) __attribute__((pure)); int type_compatible (const type_t *dst, const type_t *src) __attribute__((pure)); int type_assignable (const type_t *dst, const type_t *src); int type_same (const type_t *dst, const type_t *src) __attribute__((pure)); diff --git a/tools/qfcc/source/class.c b/tools/qfcc/source/class.c index 4f9b2e8fe..3f141ede9 100644 --- a/tools/qfcc/source/class.c +++ b/tools/qfcc/source/class.c @@ -391,7 +391,7 @@ is_method_description (const type_t *type) static protocollist_t * obj_get_class_protos (const type_t *type) { - if (is_pointer (type)) + if (is_ptr (type)) type = type->t.fldptr.type; if (is_class (type)) return type->t.class->protocols; @@ -401,7 +401,7 @@ obj_get_class_protos (const type_t *type) static protocollist_t * obj_get_protos (const type_t *type) { - if (is_pointer (type)) + if (is_ptr (type)) type = type->t.fldptr.type; return type->protos; } @@ -409,7 +409,7 @@ obj_get_protos (const type_t *type) static category_t * obj_get_categories (const type_t *type) { - if (is_pointer (type)) + if (is_ptr (type)) type = type->t.fldptr.type; if (is_class (type)) return type->t.class->categories; @@ -430,7 +430,7 @@ obj_classname (const type_t *type) } else if (is_Class (type)) { dstring_copystr (str, "Class"); } else { - if (is_pointer (type)) + if (is_ptr (type)) type = type->t.fldptr.type; if (is_class (type)) dstring_copystr (str, type->t.class->name); @@ -1738,7 +1738,7 @@ emit_protocol (protocol_t *protocol) static void emit_protocol_next (def_t *def, void *data, int index) { - if (!is_pointer(def->type)) { + if (!is_ptr(def->type)) { internal_error (0, "%s: expected pointer def", __FUNCTION__); } D_INT (def) = 0; @@ -1761,7 +1761,7 @@ emit_protocol_list_item (def_t *def, void *data, int index) protocollist_t *protocols = (protocollist_t *) data; protocol_t *protocol = protocols->list[index]; - if (!is_array (def->type) || !is_pointer(def->type->t.array.type)) { + if (!is_array (def->type) || !is_ptr(def->type->t.array.type)) { internal_error (0, "%s: expected array of pointer def", __FUNCTION__); } if (index < 0 || index >= protocols->count) { diff --git a/tools/qfcc/source/emit.c b/tools/qfcc/source/emit.c index 10c7054f9..dc5bb4b2d 100644 --- a/tools/qfcc/source/emit.c +++ b/tools/qfcc/source/emit.c @@ -90,8 +90,7 @@ get_value_def (expr_t *expr, ex_value_t *value, type_t *type) def->offset = value->v.short_val; return def; } - if (is_pointer (type) && value->v.pointer.tempop - && !value->v.pointer.def) { + if (is_ptr (type) && value->v.pointer.tempop && !value->v.pointer.def) { value->v.pointer.def = get_tempop_def (expr, value->v.pointer.tempop, type->t.fldptr.type); } diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index fe9c2f03f..df684e288 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -2816,15 +2816,14 @@ cast_expr (type_t *dstType, expr_t *e) if ((dstType == type_default && is_enum (srcType)) || (is_enum (dstType) && srcType == type_default)) return e; - if ((is_pointer (dstType) && is_string (srcType)) - || (is_string (dstType) && is_pointer (srcType))) { + if ((is_ptr (dstType) && is_string (srcType)) + || (is_string (dstType) && is_ptr (srcType))) { c = new_alias_expr (dstType, e); return c; } - if (!(is_pointer (dstType) - && (is_pointer (srcType) || is_integral (srcType) - || is_array (srcType))) - && !(is_integral (dstType) && is_pointer (srcType)) + if (!(is_ptr (dstType) && (is_ptr (srcType) || is_integral (srcType) + || is_array (srcType))) + && !(is_integral (dstType) && is_ptr (srcType)) && !(is_func (dstType) && is_func (srcType)) && !(is_scalar (dstType) && is_scalar (srcType))) { return cast_error (e, srcType, dstType); diff --git a/tools/qfcc/source/expr_assign.c b/tools/qfcc/source/expr_assign.c index a961e113d..4eec4916a 100644 --- a/tools/qfcc/source/expr_assign.c +++ b/tools/qfcc/source/expr_assign.c @@ -329,7 +329,7 @@ assign_expr (expr_t *dst, expr_t *src) internal_error (src, "src_type broke in assign_expr"); } - if (is_pointer (dst_type) && is_array (src_type)) { + if (is_ptr (dst_type) && is_array (src_type)) { // assigning an array to a pointer is the same as taking the address of // the array but using the type of the array elements src = address_expr (src, 0, src_type->t.fldptr.type); diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index f551cafc7..b647db7e6 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -646,10 +646,10 @@ pointer_arithmetic (int op, expr_t *e1, expr_t *e2) expr_t *psize; type_t *ptype; - if (!is_pointer (t1) && !is_pointer (t2)) { + if (!is_ptr (t1) && !is_ptr (t2)) { internal_error (e1, "pointer arithmetic on non-pointers"); } - if (is_pointer (t1) && is_pointer (t2)) { + if (is_ptr (t1) && is_ptr (t2)) { if (op != '-') { return error (e2, "invalid pointer operation"); } @@ -661,11 +661,11 @@ pointer_arithmetic (int op, expr_t *e1, expr_t *e2) e2 = cast_expr (&type_int, e2); psize = new_int_expr (type_size (t1->t.fldptr.type)); return binary_expr ('/', binary_expr ('-', e1, e2), psize); - } else if (is_pointer (t1)) { + } else if (is_ptr (t1)) { offset = cast_expr (&type_int, e2); ptr = cast_expr (&type_int, e1); ptype = t1; - } else if (is_pointer (t2)) { + } else if (is_ptr (t2)) { offset = cast_expr (&type_int, e1); ptr = cast_expr (&type_int, e2); ptype = t2; diff --git a/tools/qfcc/source/method.c b/tools/qfcc/source/method.c index 6fa038370..2cb88ba03 100644 --- a/tools/qfcc/source/method.c +++ b/tools/qfcc/source/method.c @@ -533,7 +533,7 @@ emit_selectors (void) static void emit_methods_next (def_t *def, void *data, int index) { - if (!is_pointer(def->type)) + if (!is_ptr(def->type)) internal_error (0, "%s: expected pointer def", __FUNCTION__); D_INT (def) = 0; } diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index dcdde6c7b..3f4774f30 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -554,7 +554,7 @@ unalias_type (const type_t *type) const type_t * dereference_type (const type_t *type) { - if (!is_pointer (type) && !is_field (type)) { + if (!is_ptr (type) && !is_field (type)) { internal_error (0, "dereference non pointer/field type"); } if (type->meta == ty_alias) { @@ -836,12 +836,13 @@ encode_type (dstring_t *encoding, const type_t *type) internal_error (0, "bad type meta:type %d:%d", type->meta, type->type); } -int -is_void (const type_t *type) -{ - type = unalias_type (type); - return type->type == ev_void; +#define EV_TYPE(t) \ +int is_##t (const type_t *type) \ +{ \ + type = unalias_type (type); \ + return type->type == ev_##t; \ } +#include "QF/progs/pr_type_names.h" int is_enum (const type_t *type) @@ -852,39 +853,6 @@ is_enum (const type_t *type) return 0; } -int -is_int (const type_t *type) -{ - type = unalias_type (type); - etype_t t = type->type; - - if (t == ev_int) - return 1; - return is_enum (type); -} - -int -is_uint (const type_t *type) -{ - type = unalias_type (type); - etype_t t = type->type; - - if (t == ev_uint) - return 1; - return is_enum (type); -} - -int -is_short (const type_t *type) -{ - type = unalias_type (type); - etype_t t = type->type; - - if (t == ev_short) - return 1; - return is_enum (type); -} - int is_integral (const type_t *type) { @@ -894,20 +862,6 @@ is_integral (const type_t *type) return is_enum (type); } -int -is_double (const type_t *type) -{ - type = unalias_type (type); - return type->type == ev_double; -} - -int -is_float (const type_t *type) -{ - type = unalias_type (type); - return type->type == ev_float; -} - int is_scalar (const type_t *type) { @@ -915,20 +869,6 @@ is_scalar (const type_t *type) return is_float (type) || is_integral (type) || is_double (type); } -int -is_vector (const type_t *type) -{ - type = unalias_type (type); - return type->type == ev_vector; -} - -int -is_quaternion (const type_t *type) -{ - type = unalias_type (type); - return type->type == ev_quaternion; -} - int is_math (const type_t *type) { @@ -948,33 +888,6 @@ is_struct (const type_t *type) return 0; } -int -is_pointer (const type_t *type) -{ - type = unalias_type (type); - if (type->type == ev_ptr) - return 1; - return 0; -} - -int -is_field (const type_t *type) -{ - type = unalias_type (type); - if (type->type == ev_field) - return 1; - return 0; -} - -int -is_entity (const type_t *type) -{ - type = unalias_type (type); - if (type->type == ev_entity) - return 1; - return 0; -} - int is_array (const type_t *type) { @@ -984,15 +897,6 @@ is_array (const type_t *type) return 0; } -int -is_func (const type_t *type) -{ - type = unalias_type (type); - if (type->type == ev_func) - return 1; - return 0; -} - int is_structural (const type_t *type) { @@ -1000,15 +904,6 @@ is_structural (const type_t *type) return is_struct (type) || is_array (type); } -int -is_string (const type_t *type) -{ - type = unalias_type (type); - if (type->type == ev_string) - return 1; - return 0; -} - int type_compatible (const type_t *dst, const type_t *src) { @@ -1022,7 +917,7 @@ type_compatible (const type_t *dst, const type_t *src) if (is_func (dst) && is_func (src)) { return 1; } - if (is_pointer (dst) && is_pointer (src)) { + if (is_ptr (dst) && is_ptr (src)) { return 1; } return 0; @@ -1042,12 +937,12 @@ type_assignable (const type_t *dst, const type_t *src) if (dst->type == ev_field && src->type == ev_field) return 1; // pointer = array - if (is_pointer (dst) && is_array (src)) { + if (is_ptr (dst) && is_array (src)) { if (dst->t.fldptr.type == src->t.array.type) return 1; return 0; } - if (!is_pointer (dst) || !is_pointer (src)) + if (!is_ptr (dst) || !is_ptr (src)) return is_scalar (dst) && is_scalar (src); // pointer = pointer From df890432b730c86125031d35bac3503c982e22a2 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 19 Jan 2022 18:08:58 +0900 Subject: [PATCH 154/360] [qfcc] Add support for unsigned, long, etc long is ignored for double, and v6p progs are stuck with 32 bits for longs (don't feel like extending v6p any further), but the basics are there for Ruamoko. short is ignored for ints because the minimum size is 32, and signed is just noise for ints anyway (and no chars, so...). unsigned, however, is finally implemented properly (or at least seems to be working correctly: tests pass after getting things compiling again, and lt.u is used where it should be :) --- libs/video/renderer/vulkan/vkgen/stdint.h | 1 - tools/qfcc/include/type.h | 2 + tools/qfcc/source/expr_binary.c | 72 ++++++------- tools/qfcc/source/opcodes.c | 80 +++++++++++++-- tools/qfcc/source/qc-lex.l | 5 +- tools/qfcc/source/qc-parse.y | 119 ++++++++++++++++++---- tools/qfcc/source/type.c | 10 ++ 7 files changed, 225 insertions(+), 64 deletions(-) diff --git a/libs/video/renderer/vulkan/vkgen/stdint.h b/libs/video/renderer/vulkan/vkgen/stdint.h index 04fc06933..e343a15b5 100644 --- a/libs/video/renderer/vulkan/vkgen/stdint.h +++ b/libs/video/renderer/vulkan/vkgen/stdint.h @@ -7,5 +7,4 @@ typedef int int16_t; typedef int int32_t; typedef int int64_t; typedef int size_t; -typedef int long; typedef int char; diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h index d6d93ede8..4a65b3384 100644 --- a/tools/qfcc/include/type.h +++ b/tools/qfcc/include/type.h @@ -104,6 +104,8 @@ extern type_t type_floatfield; extern type_t *type_nil; // for passing nil into ... extern type_t *type_default; // default type (float or int) +extern type_t *type_long_int; // supported type for long +extern type_t *type_ulong_uint;// supported type for ulong extern type_t type_va_list; extern type_t type_param; diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index b647db7e6..27e7f1ff8 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -290,23 +290,23 @@ static expr_type_t int_int[] = { }; static expr_type_t int_uint[] = { - {'+', &type_int}, - {'-', &type_int}, - {'*', &type_int}, - {'/', &type_int}, - {'&', &type_int}, - {'|', &type_int}, - {'^', &type_int}, - {'%', &type_int}, - {MOD, &type_int}, - {SHL, &type_int}, - {SHR, &type_int}, - {EQ, &type_int}, - {NE, &type_int}, - {LE, &type_int}, - {GE, &type_int}, - {LT, &type_int}, - {GT, &type_int}, + {'+', &type_int, 0, &type_int}, + {'-', &type_int, 0, &type_int}, + {'*', &type_int, 0, &type_int}, + {'/', &type_int, 0, &type_int}, + {'&', &type_int, 0, &type_int}, + {'|', &type_int, 0, &type_int}, + {'^', &type_int, 0, &type_int}, + {'%', &type_int, 0, &type_int}, + {MOD, &type_int, 0, &type_int}, + {SHL, &type_int, 0, &type_int}, + {SHR, &type_int, 0, &type_int}, + {EQ, &type_int, 0, &type_int}, + {NE, &type_int, 0, &type_int}, + {LE, &type_int, 0, &type_int}, + {GE, &type_int, 0, &type_int}, + {LT, &type_int, 0, &type_int}, + {GT, &type_int, 0, &type_int}, {0, 0} }; @@ -353,23 +353,23 @@ static expr_type_t int_double[] = { #define uint_quat int_quat static expr_type_t uint_int[] = { - {'+', &type_int}, - {'-', &type_int}, - {'*', &type_int}, - {'/', &type_int}, - {'&', &type_int}, - {'|', &type_int}, - {'^', &type_int}, - {'%', &type_int}, - {MOD, &type_int}, - {SHL, &type_uint}, - {SHR, &type_uint}, - {EQ, &type_int}, - {NE, &type_int}, - {LE, &type_int}, - {GE, &type_int}, - {LT, &type_int}, - {GT, &type_int}, + {'+', &type_int, &type_int, &type_int }, + {'-', &type_int, &type_int, &type_int }, + {'*', &type_int, &type_int, &type_int }, + {'/', &type_int, &type_int, &type_int }, + {'&', &type_int, &type_int, &type_int }, + {'|', &type_int, &type_int, &type_int }, + {'^', &type_int, &type_int, &type_int }, + {'%', &type_int, &type_int, &type_int }, + {MOD, &type_int, &type_int, &type_int }, + {SHL, &type_uint, &type_int, &type_int }, + {SHR, &type_uint, 0, &type_int }, + {EQ, &type_int, &type_int, &type_int }, + {NE, &type_int, &type_int, &type_int }, + {LE, &type_int, &type_int, &type_int }, + {GE, &type_int, &type_int, &type_int }, + {LT, &type_int, &type_int, &type_int }, + {GT, &type_int, &type_int, &type_int }, {0, 0} }; @@ -385,8 +385,8 @@ static expr_type_t uint_uint[] = { {MOD, &type_uint}, {SHL, &type_uint}, {SHR, &type_uint}, - {EQ, &type_int}, - {NE, &type_int}, + {EQ, &type_int, &type_int, &type_int}, + {NE, &type_int, &type_int, &type_int}, {LE, &type_int}, {GE, &type_int}, {LT, &type_int}, diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index 47accd2c3..9ac87ea10 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -47,8 +47,38 @@ #include "tools/qfcc/include/statements.h" #include "tools/qfcc/include/type.h" +typedef struct v6p_uint_opcode_s { + pr_opcode_v6p_e op; + v6p_opcode_t opcode; +} v6p_uint_opcode_t; + +static v6p_uint_opcode_t v6p_uint_opcodes[] = { + {OP_LOAD_I_v6p, {".", "load.i", ev_entity, ev_field, ev_uint }}, + {OP_LOADBI_I_v6p, {".", "loadbi.i", ev_ptr, ev_short, ev_uint }}, + {OP_ADDRESS_I_v6p, {"&", "address.i", ev_uint, ev_invalid, ev_ptr }}, + {OP_STORE_I_v6p, {"=", "store.i", ev_uint, ev_uint, ev_invalid }}, + {OP_STOREP_I_v6p, {".=", "storep.i", ev_uint, ev_ptr, ev_invalid }}, + {OP_STOREB_I_v6p, {".=", "storeb.i", ev_uint, ev_ptr, ev_int }}, + {OP_STOREBI_I_v6p, {".=", "storebi.i", ev_uint, ev_ptr, ev_short }}, + {OP_IF_v6p, {"", "if", ev_uint, ev_short, ev_invalid }}, + {OP_IFNOT_v6p, {"", "ifnot", ev_uint, ev_short, ev_invalid }}, + {OP_ADD_I_v6p, {"+", "add.i", ev_uint, ev_uint, ev_uint }}, + {OP_SUB_I_v6p, {"-", "sub.i", ev_uint, ev_uint, ev_uint }}, + {OP_MUL_I_v6p, {"*", "mul.i", ev_uint, ev_uint, ev_uint }}, + {OP_DIV_I_v6p, {"/", "div.i", ev_uint, ev_uint, ev_uint }}, + {OP_BITAND_I_v6p, {"&", "bitand.i", ev_uint, ev_uint, ev_uint }}, + {OP_BITOR_I_v6p, {"|", "bitor.i", ev_uint, ev_uint, ev_uint }}, + {OP_BITXOR_I_v6p, {"^", "bitxor.i", ev_uint, ev_uint, ev_uint }}, + {OP_REM_I_v6p, {"%", "rem.i", ev_uint, ev_uint, ev_uint }}, + {OP_MOD_I_v6p, {"%%", "mod.i", ev_uint, ev_uint, ev_uint }}, + {OP_SHL_I_v6p, {"<<", "shl.i", ev_uint, ev_uint, ev_uint }}, + {OP_BITNOT_I_v6p, {"<<", "bitnot.i", ev_uint, ev_invalid, ev_int }}, + {} +}; + static hashtab_t *v6p_opcode_type_table; static hashtab_t *v6p_opcode_void_table; +static hashtab_t *v6p_opcode_uint_table; static v6p_opcode_t *v6p_opcode_map; static hashtab_t *rua_opcode_type_table; @@ -86,6 +116,21 @@ v6p_get_key (const void *op, void *unused) return ((v6p_opcode_t *) op)->name; } +static uintptr_t +v6p_uint_get_hash (const void *_op, void *_tab) +{ + __auto_type uint_op = (v6p_uint_opcode_t *) _op; + return v6p_get_hash (&uint_op->opcode, _tab); +} + +static int +v6p_uint_compare (const void *_opa, const void *_opb, void *data) +{ + __auto_type uint_opa = (v6p_uint_opcode_t *) _opa; + __auto_type uint_opb = (v6p_uint_opcode_t *) _opb; + return v6p_compare (&uint_opa->opcode, &uint_opb->opcode, data); +} + static uintptr_t rua_get_hash (const void *_op, void *_tab) { @@ -139,17 +184,25 @@ static v6p_opcode_t * v6p_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, operand_t *op_c) { - v6p_opcode_t search_op = {}; + v6p_uint_opcode_t search_op = { + .opcode = { + .name = name, + .type_a = op_a ? low_level_type (op_a->type) : ev_invalid, + .type_b = op_b ? low_level_type (op_b->type) : ev_invalid, + .type_c = op_c ? low_level_type (op_c->type) : ev_invalid, + }, + }; + v6p_uint_opcode_t *uint_op; v6p_opcode_t *op; v6p_opcode_t *sop; void **op_list; int i; - search_op.name = name; - search_op.type_a = op_a ? low_level_type (op_a->type) : ev_invalid; - search_op.type_b = op_b ? low_level_type (op_b->type) : ev_invalid; - search_op.type_c = op_c ? low_level_type (op_c->type) : ev_invalid; - op = Hash_FindElement (v6p_opcode_type_table, &search_op); + uint_op = Hash_FindElement (v6p_opcode_uint_table, &search_op); + if (uint_op) { + return v6p_opcode_map + uint_op->op; + } + op = Hash_FindElement (v6p_opcode_type_table, &search_op.opcode); if (op) return op; op_list = Hash_FindList (v6p_opcode_void_table, name); @@ -157,9 +210,9 @@ v6p_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, return op; for (i = 0; !op && op_list[i]; i++) { sop = op_list[i]; - if (check_operand_type (sop->type_a, search_op.type_a) - && check_operand_type (sop->type_b, search_op.type_b) - && check_operand_type (sop->type_c, search_op.type_c)) + if (check_operand_type (sop->type_a, search_op.opcode.type_a) + && check_operand_type (sop->type_b, search_op.opcode.type_b) + && check_operand_type (sop->type_c, search_op.opcode.type_c)) op = sop; } free (op_list); @@ -217,10 +270,14 @@ v6p_opcode_init (void) if (v6p_opcode_type_table) { Hash_FlushTable (v6p_opcode_void_table); Hash_FlushTable (v6p_opcode_type_table); + Hash_FlushTable (v6p_opcode_uint_table); } else { v6p_opcode_type_table = Hash_NewTable (1021, 0, 0, 0, 0); Hash_SetHashCompare (v6p_opcode_type_table, v6p_get_hash, v6p_compare); v6p_opcode_void_table = Hash_NewTable (1021, v6p_get_key, 0, 0, 0); + v6p_opcode_uint_table = Hash_NewTable (1021, 0, 0, 0, 0); + Hash_SetHashCompare (v6p_opcode_uint_table, + v6p_uint_get_hash, v6p_uint_compare); } int num_opcodes = 0; @@ -253,6 +310,11 @@ v6p_opcode_init (void) || mop->type_c == ev_void) Hash_Add (v6p_opcode_void_table, mop); } + if (options.code.progsversion != PROG_ID_VERSION) { + for (__auto_type uiop = &v6p_uint_opcodes[0]; uiop->op; uiop++) { + Hash_AddElement (v6p_opcode_uint_table, uiop); + } + } } static void diff --git a/tools/qfcc/source/qc-lex.l b/tools/qfcc/source/qc-lex.l index ed742fc52..6a9121e64 100644 --- a/tools/qfcc/source/qc-lex.l +++ b/tools/qfcc/source/qc-lex.l @@ -377,7 +377,10 @@ static keyword_t qf_keywords[] = { {"quaternion", TYPE, &type_quaternion}, {"double", TYPE, &type_double}, {"int", TYPE, &type_int }, - {"unsigned", TYPE, &type_int },//FIXME + {"unsigned", UNSIGNED, 0 }, + {"signed", SIGNED, 0 }, + {"long", LONG, 0 }, + {"short", SHORT, 0 }, {"@function", TYPE, &type_func }, {"@args", ARGS, 0 }, diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index 454c8fcfc..26e6f1f38 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -148,6 +148,7 @@ int yylex (void); %token LOCAL RETURN WHILE DO IF ELSE FOR BREAK CONTINUE ELLIPSIS %token NIL GOTO SWITCH CASE DEFAULT ENUM %token ARGS TYPEDEF EXTERN STATIC SYSTEM NOSAVE OVERLOAD NOT +%token UNSIGNED SIGNED LONG SHORT %token STRUCT %token TYPE %token OBJECT TYPE_NAME @@ -253,6 +254,23 @@ spec_merge (specifier_t spec, specifier_t new) spec.storage = new.storage; spec.is_typedef = new.is_typedef; } + if ((new.is_unsigned && spec.is_signed) + || (new.is_signed && spec.is_unsigned)) { + if (!spec.multi_type) { + error (0, "both signed and unsigned in declaration specifiers"); + spec.multi_type = 1; + } + } + if ((new.is_long && spec.is_short) || (new.is_short && spec.is_long)) { + if (!spec.multi_store) { + error (0, "both long and short in declaration specifiers"); + spec.multi_store = 1; + } + } + spec.is_signed |= new.is_signed; + spec.is_unsigned |= new.is_unsigned; + spec.is_short |= new.is_short; + spec.is_long |= new.is_long; spec.is_overload |= new.is_overload; spec.nosave |= new.nosave; return spec; @@ -261,6 +279,59 @@ spec_merge (specifier_t spec, specifier_t new) static specifier_t default_type (specifier_t spec, symbol_t *sym) { + if (spec.type) { + if (is_float (spec.type) && !spec.multi_type) { + // no modifieres allowed + if (spec.is_unsigned) { + spec.multi_type = 1; + error (0, "both unsigned and float in declaration specifiers"); + } else if (spec.is_signed) { + spec.multi_type = 1; + error (0, "both signed and float in declaration specifiers"); + } else if (spec.is_short) { + spec.multi_type = 1; + error (0, "both short and float in declaration specifiers"); + } else if (spec.is_long) { + spec.multi_type = 1; + error (0, "both long and float in declaration specifiers"); + } + } + if (is_double (spec.type)) { + // long is allowed but ignored + if (spec.is_unsigned) { + spec.multi_type = 1; + error (0, "both unsigned and double in declaration specifiers"); + } else if (spec.is_signed) { + spec.multi_type = 1; + error (0, "both signed and double in declaration specifiers"); + } else if (spec.is_short) { + spec.multi_type = 1; + error (0, "both short and double in declaration specifiers"); + } + } + if (is_int (spec.type)) { + // signed and short are ignored + if (spec.is_unsigned && spec.is_long) { + spec.type = &type_ulong; + } else if (spec.is_long) { + spec.type = &type_long; + } + } + } else { + if (spec.is_long) { + if (spec.is_unsigned) { + spec.type = type_ulong_uint; + } else { + spec.type = type_long_int; + } + } else { + if (spec.is_unsigned) { + spec.type = &type_uint; + } else if (spec.is_signed) { + spec.type = &type_int; + } + } + } if (!spec.type) { spec.type = type_default; warning (0, "type defaults to '%s' in declaration of '%s'", @@ -414,11 +485,10 @@ function_body : optional_state_expr { symbol_t *sym = $0; + specifier_t spec = default_type ($-1, sym); - if (!$-1.type) - $-1.type = type_default; - sym->type = find_type (append_type (sym->type, $-1.type)); - $$ = function_symbol (sym, $-1.is_overload, 1); + sym->type = find_type (append_type (sym->type, spec.type)); + $$ = function_symbol (sym, spec.is_overload, 1); } save_storage { @@ -438,12 +508,11 @@ function_body | '=' '#' expr ';' { symbol_t *sym = $0; + specifier_t spec = default_type ($-1, sym); - if (!$-1.type) - $-1.type = type_default; - sym->type = find_type (append_type (sym->type, $-1.type)); - sym = function_symbol (sym, $-1.is_overload, 1); - build_builtin_function (sym, $3, 0, $-1.storage); + sym->type = find_type (append_type (sym->type, spec.type)); + sym = function_symbol (sym, spec.is_overload, 1); + build_builtin_function (sym, $3, 0, spec.storage); } ; @@ -556,6 +625,26 @@ type_specifier { $$ = make_spec ($1, 0, 0, 0); } + | UNSIGNED + { + $$ = make_spec (0, current_storage, 0, 0); + $$.is_unsigned = 1; + } + | SIGNED + { + $$ = make_spec (0, current_storage, 0, 0); + $$.is_signed = 1; + } + | LONG + { + $$ = make_spec (0, current_storage, 0, 0); + $$.is_long = 1; + } + | SHORT + { + $$ = make_spec (0, current_storage, 0, 0); + $$.is_short = 1; + } | enum_specifier | struct_specifier | TYPE_NAME @@ -768,8 +857,7 @@ struct_decl_list struct_decl : function_decl { - if (!$0.type) - $0.type = type_default; + $0 = default_type ($-0, $1); $1->type = find_type (append_type ($1->type, $0.type)); $1->sy_type = sy_var; $1->visibility = current_visibility; @@ -780,8 +868,7 @@ struct_decl } | var_decl { - if (!$0.type) - $0.type = type_default; + $0 = default_type ($-0, $1); $1->type = find_type (append_type ($1->type, $0.type)); $1->sy_type = sy_var; $1->visibility = current_visibility; @@ -900,8 +987,7 @@ qc_var_list param_declaration : type var_decl { - if (!$1.type) - $1.type = type_default; + $1 = default_type ($1, $2); $2->type = find_type (append_type ($2->type, $1.type)); $$ = new_param (0, $2->type, $2->name); } @@ -913,8 +999,7 @@ abstract_decl : type abs_decl { $$ = $2; - if (!$1.type) - $1.type = type_default; + $1 = default_type ($1, $2); $$->type = find_type (append_type ($$->type, $1.type)); } | error { $$ = new_symbol (""); } diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index 3f4774f30..76a8e5976 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -76,6 +76,8 @@ type_t type_invalid = { ev_invalid, "invalid" }; type_t *type_nil; type_t *type_default; +type_t *type_long_int; +type_t *type_ulong_uint; // these will be built up further type_t type_va_list = { ev_invalid, 0, 0, ty_struct }; @@ -1118,6 +1120,14 @@ init_types (void) type_nil = &type_quaternion; type_default = &type_int; + type_long_int = &type_long; + type_ulong_uint = &type_ulong; + if (options.code.progsversion < PROG_VERSION) { + // even v6p doesn't support long, and I don't feel like adding it + // use ruamoko :P + type_long_int = &type_int; + type_ulong_uint = &type_uint; + } if (options.code.progsversion == PROG_ID_VERSION) { // vector can't be part of .zero for v6 progs because for v6 progs, // .zero is only one word wide. From 9f42cf726bb4243f236afb0c2a32290916ad8abd Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 19 Jan 2022 21:18:34 +0900 Subject: [PATCH 155/360] [qfcc] Clean up duplicate specifier check code I don't like the name, but having two identical copies of code is never a good thing, especially something that big. --- tools/qfcc/source/qc-parse.y | 55 +++++++++++++++--------------------- 1 file changed, 23 insertions(+), 32 deletions(-) diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index 26e6f1f38..b087c69df 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -367,6 +367,27 @@ is_null_spec (specifier_t spec) return memcmp (&spec, &null_spec, sizeof (spec)) == 0; } +static void +check_specifiers (specifier_t spec) +{ + if (!is_null_spec (spec)) { + if (!spec.type && !spec.sym) { + warning (0, "useless specifiers"); + } else if (spec.type && !spec.sym) { + if (is_anonymous_struct (spec)){ + warning (0, "unnamed struct/union that defines " + "no instances"); + } else if (!is_enum (spec.type) && !is_struct (spec.type)) { + warning (0, "useless type name in empty declaration"); + } + } else if (!spec.type && spec.sym) { + bug (0, "wha? %p %p", spec.type, spec.sym); + } else { + bug (0, "wha? %p %p", spec.type, spec.sym); + } + } +} + %} %expect 0 @@ -417,22 +438,7 @@ external_def : optional_specifiers external_decl_list ';' { } | optional_specifiers ';' { - if (!is_null_spec ($1)) { - if (!$1.type && !$1.sym) { - warning (0, "useless specifiers"); - } else if ($1.type && !$1.sym) { - if (is_anonymous_struct ($1)){ - warning (0, "unnamed struct/union that defines " - "no instances"); - } else if (!is_enum ($1.type) && !is_struct ($1.type)) { - warning (0, "useless type name in empty declaration"); - } - } else if (!$1.type && $1.sym) { - bug (0, "wha? %p %p", $1.type, $1.sym); - } else { - bug (0, "wha? %p %p", $1.type, $1.sym); - } - } + check_specifiers ($1); } | optional_specifiers qc_func_params { @@ -1329,22 +1335,7 @@ local_def } | specifiers ';' { - if (!is_null_spec ($1)) { - if (!$1.type && !$1.sym) { - warning (0, "useless specifiers"); - } else if ($1.type && !$1.sym) { - if (is_anonymous_struct ($1)){ - warning (0, "unnamed struct/union that defines " - "no instances"); - } else if (!is_enum ($1.type) && !is_struct ($1.type)) { - warning (0, "useless type name in empty declaration"); - } - } else if (!$1.type && $1.sym) { - bug (0, "wha? %p %p", $1.type, $1.sym); - } else { - bug (0, "wha? %p %p", $1.type, $1.sym); - } - } + check_specifiers ($1); $$ = 0; } ; From 07c4d28638ebb93e5601c1513ed1b6f6a731bcc7 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 19 Jan 2022 21:21:27 +0900 Subject: [PATCH 156/360] [qfcc] Handle bare "short" Missed this case in duplicate_type. Allows "short foo" and "sizeof(short)" (even though qfcc and the engine have two ideas of the size: I expect trouble later). --- tools/qfcc/source/qc-parse.y | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index b087c69df..cecf04866 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -327,7 +327,7 @@ default_type (specifier_t spec, symbol_t *sym) } else { if (spec.is_unsigned) { spec.type = &type_uint; - } else if (spec.is_signed) { + } else if (spec.is_signed || spec.is_short) { spec.type = &type_int; } } From 4ae94743968ce3928ced94ebc65a0c1ffb5c9003 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 19 Jan 2022 21:26:44 +0900 Subject: [PATCH 157/360] [ruamoko] Use pr_type_names for type sizes short and ushort are "wrong" (1 instead of 0, because qfcc currently uses int for short), but now the array will always be in sync with the enum. --- ruamoko/lib/types.r | 26 ++++++++------------------ 1 file changed, 8 insertions(+), 18 deletions(-) diff --git a/ruamoko/lib/types.r b/ruamoko/lib/types.r index 0445e0510..7c27914ff 100644 --- a/ruamoko/lib/types.r +++ b/ruamoko/lib/types.r @@ -12,25 +12,15 @@ string ty_meta_name[7] = { }; //FIXME use pr_type_names.h, but need to fix unsigned, and add missing types -//#define EV_TYPE(type) sizeof(type), +#define field .int +#define func void()(void) +#define ptr void * +#define uint unsigned +#define ulong unsigned long +#define ushort unsigned short +#define EV_TYPE(type) sizeof(type), int pr_type_size[ev_type_count] = { -//#include - 1, // ev_void - 1, // ev_string - 1, // ev_float - 3, // ev_vector - 1, // ev_entity - 1, // ev_field - 1, // ev_func - 1, // ev_ptr - 4, // ev_quat - 1, // ev_integer - 1, // ev_uinteger - 0, // ev_short value in opcode - 2, // ev_double - 2, // ev_long - 2, // ev_ulong - 0, // ev_invalid not a valid/simple type +#include }; #define EV_TYPE(type) #type, From 105d57f5e7ec82695a0c47c95f36b1ec3a50baaa Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 19 Jan 2022 21:32:01 +0900 Subject: [PATCH 158/360] [qfcc] Improve handling of type names as variables This is allowed in C so long as the scopes are different. --- tools/qfcc/source/qc-lex.l | 12 ++++++++++ tools/qfcc/source/qc-parse.y | 43 +++++++++++++++++++++++++++--------- tools/qfcc/source/symtab.c | 4 +++- 3 files changed, 48 insertions(+), 11 deletions(-) diff --git a/tools/qfcc/source/qc-lex.l b/tools/qfcc/source/qc-lex.l index 6a9121e64..7ce445539 100644 --- a/tools/qfcc/source/qc-lex.l +++ b/tools/qfcc/source/qc-lex.l @@ -422,6 +422,18 @@ process_keyword (keyword_t *keyword, const char *token) sym = symtab_lookup (current_symtab, token); qc_yylval.symbol = sym; + // the global id symbol is always just a name so attempts to redefine + // it globally can be caught and treated as an error, but it needs to + // be redefinable when in an enclosing scope. + if (sym->sy_type == sy_name) { + // this is the global id (object) + return OBJECT; + } else if (sym->sy_type == sy_type) { + // id has been redeclared via a typedef + return TYPE_NAME; + } + // id has been redelcared as a variable (hopefully) + return NAME; } else { qc_yylval.type = keyword->type; } diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index cecf04866..a9c2ea102 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -267,6 +267,7 @@ spec_merge (specifier_t spec, specifier_t new) spec.multi_store = 1; } } + spec.sym = new.sym; spec.is_signed |= new.is_signed; spec.is_unsigned |= new.is_unsigned; spec.is_short |= new.is_short; @@ -367,6 +368,16 @@ is_null_spec (specifier_t spec) return memcmp (&spec, &null_spec, sizeof (spec)) == 0; } +static int +use_type_name (specifier_t spec) +{ + spec.sym = new_symbol (spec.sym->name); + spec.sym->type = spec.type; + spec.sym->sy_type = sy_var; + symtab_addsymbol (current_symtab, spec.sym); + return !!spec.sym->table; +} + static void check_specifiers (specifier_t spec) { @@ -383,7 +394,12 @@ check_specifiers (specifier_t spec) } else if (!spec.type && spec.sym) { bug (0, "wha? %p %p", spec.type, spec.sym); } else { - bug (0, "wha? %p %p", spec.type, spec.sym); + // a type name (id, typedef, etc) was used as a variable name. + // this is allowed in C, so long as it's in a different scope + if (!use_type_name (spec)) { + error (0, "%s redeclared as different kind of symbol", + spec.sym->name); + } } } } @@ -614,7 +630,9 @@ type // deal with eg "int id" $1.sym = $2.sym; - if (!$1.sym) { + if (!$1.sym && !$1.type) { + $1 = spec_merge ($1, $2); + } else if (!$1.sym) { error (0, "two or more data types in declaration specifiers"); } $$ = $1; @@ -827,11 +845,7 @@ struct_def if ($1.sym && $1.sym->type != $1.type) { // a type name (id, typedef, etc) was used as a field name. // this is allowed in C - $1.sym = new_symbol ($1.sym->name); - $1.sym->type = $1.type; - $1.sym->sy_type = sy_var; - symtab_addsymbol (current_symtab, $1.sym); - if (!$1.sym->table) { + if (!use_type_name ($1)) { error (0, "duplicate field `%s'", $1.sym->name); } } else if (is_anonymous_struct ($1)) { @@ -997,18 +1011,27 @@ param_declaration $2->type = find_type (append_type ($2->type, $1.type)); $$ = new_param (0, $2->type, $2->name); } - | abstract_decl { $$ = new_param (0, $1->type, 0); } + | abstract_decl { $$ = new_param (0, $1->type, $1->name); } | ELLIPSIS { $$ = new_param (0, 0, 0); } ; abstract_decl : type abs_decl { + // abs_decl's symbol is just a carrier for the type + if ($2->name) { + bug (0, "unexpected name in abs_decl"); + } + if ($1.sym) { + $1.sym = new_symbol ($1.sym->name); + $1.sym->type = $2->type; + $2 = $1.sym; + } $$ = $2; $1 = default_type ($1, $2); $$->type = find_type (append_type ($$->type, $1.type)); } - | error { $$ = new_symbol (""); } + | error { $$ = new_symbol (0); } ; qc_param_decl @@ -1035,7 +1058,7 @@ qc_param_decl ; abs_decl - : /* empty */ { $$ = new_symbol (""); } + : /* empty */ { $$ = new_symbol (0); } | '(' abs_decl ')' function_params { $$ = $2; diff --git a/tools/qfcc/source/symtab.c b/tools/qfcc/source/symtab.c index ca08069bf..6261b66ee 100644 --- a/tools/qfcc/source/symtab.c +++ b/tools/qfcc/source/symtab.c @@ -75,7 +75,9 @@ new_symbol (const char *name) { symbol_t *symbol; ALLOC (256, symbol_t, symbols, symbol); - symbol->name = save_string (name); + if (name) { + symbol->name = save_string (name); + } return symbol; } From 30008aeb1370aacb03ef4427176c89e0db46476e Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 00:42:29 +0900 Subject: [PATCH 159/360] [qfcc] Fix a missed address expression conversion Found while testing operator renaming. --- tools/qfcc/include/class.h | 1 + tools/qfcc/source/expr_obj.c | 4 ++-- tools/qfcc/source/method.c | 2 +- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/tools/qfcc/include/class.h b/tools/qfcc/include/class.h index ec160e1d9..217227a73 100644 --- a/tools/qfcc/include/class.h +++ b/tools/qfcc/include/class.h @@ -94,6 +94,7 @@ extern struct type_s type_object; extern struct type_s type_class; extern struct type_s type_Class; extern struct type_s type_protocol; +extern struct type_s type_selector; extern struct type_s type_SEL; extern struct type_s type_IMP; extern struct type_s type_supermsg; diff --git a/tools/qfcc/source/expr_obj.c b/tools/qfcc/source/expr_obj.c index 9c3984055..33eadb742 100644 --- a/tools/qfcc/source/expr_obj.c +++ b/tools/qfcc/source/expr_obj.c @@ -112,8 +112,8 @@ selector_expr (keywordarg_t *selector) reloc_def_def (sel_table->s.def, sel_sym->s.def); } sel_ref = new_symbol_expr (sel_sym); - sel_ref = new_binary_expr ('&', sel_ref, new_short_expr (index)); - sel_ref->e.expr.type = &type_SEL; + sel_ref = new_address_expr (&type_selector, sel_ref, + new_short_expr (index)); expr_t *sel = new_expr (); sel->type = ex_selector; diff --git a/tools/qfcc/source/method.c b/tools/qfcc/source/method.c index 2cb88ba03..b4cae8e08 100644 --- a/tools/qfcc/source/method.c +++ b/tools/qfcc/source/method.c @@ -492,7 +492,7 @@ get_selector (expr_t *sel) error (sel, "not a selector"); return 0; } - _sel.index = expr_short (sel->e.expr.e2); + _sel.index = expr_short (sel->e.address.offset); _sel.index /= type_size (type_SEL.t.fldptr.type); return (selector_t *) Hash_FindElement (sel_index_hash, &_sel); } From 143030fec4cfd4a3be06bfc83a90b1a6dafde005 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 09:26:01 +0900 Subject: [PATCH 160/360] [gamecode] Use text for all v6p opcode names This makes the v6p instruction table consistent with the ruamoko instruction table, and clears up some of the ugliness with the load, store, and assign instructions (. .= and = are now spelled out). I think I'd still prefer an enum code (faster) but at least this is more readable. --- libs/gamecode/pr_v6p_opcode.c | 584 ++++++++++++++++----------------- tools/qfcc/source/dags.c | 24 +- tools/qfcc/source/flow.c | 24 +- tools/qfcc/source/opcodes.c | 40 +-- tools/qfcc/source/statements.c | 138 ++++---- 5 files changed, 405 insertions(+), 405 deletions(-) diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index 6b8988474..20f717154 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -62,1412 +62,1412 @@ // 0-7 parameter index (for P) VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { // OP_DONE_v6p is actually the same as OP_RETURN_v6p, the types are bogus - [OP_DONE_v6p] = {"", "done", + [OP_DONE_v6p] = {"done", "done", ev_entity, ev_field, ev_void, PROG_ID_VERSION, "%Va", }, - [OP_MUL_D_v6p] = {"*", "mul.d", + [OP_MUL_D_v6p] = {"mul", "mul.d", ev_double, ev_double, ev_double, PROG_V6P_VERSION, }, - [OP_MUL_F_v6p] = {"*", "mul.f", + [OP_MUL_F_v6p] = {"mul", "mul.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_MUL_V_v6p] = {"*", "mul.v", + [OP_MUL_V_v6p] = {"mul", "mul.v", ev_vector, ev_vector, ev_float, PROG_ID_VERSION, }, - [OP_MUL_FV_v6p] = {"*", "mul.fv", + [OP_MUL_FV_v6p] = {"mul", "mul.fv", ev_float, ev_vector, ev_vector, PROG_ID_VERSION, }, - [OP_MUL_VF_v6p] = {"*", "mul.vf", + [OP_MUL_VF_v6p] = {"mul", "mul.vf", ev_vector, ev_float, ev_vector, PROG_ID_VERSION, }, - [OP_MUL_DV_v6p] = {"*", "mul.dv", + [OP_MUL_DV_v6p] = {"mul", "mul.dv", ev_double, ev_vector, ev_vector, PROG_ID_VERSION, }, - [OP_MUL_VD_v6p] = {"*", "mul.vd", + [OP_MUL_VD_v6p] = {"mul", "mul.vd", ev_vector, ev_double, ev_vector, PROG_ID_VERSION, }, - [OP_MUL_Q_v6p] = {"*", "mul.q", + [OP_MUL_Q_v6p] = {"mul", "mul.q", ev_quaternion, ev_quaternion, ev_quaternion, PROG_V6P_VERSION, }, - [OP_MUL_FQ_v6p] = {"*", "mul.fq", + [OP_MUL_FQ_v6p] = {"mul", "mul.fq", ev_float, ev_quaternion, ev_quaternion, PROG_V6P_VERSION, }, - [OP_MUL_QF_v6p] = {"*", "mul.qf", + [OP_MUL_QF_v6p] = {"mul", "mul.qf", ev_quaternion, ev_float, ev_quaternion, PROG_V6P_VERSION, }, - [OP_MUL_DQ_v6p] = {"*", "mul.dq", + [OP_MUL_DQ_v6p] = {"mul", "mul.dq", ev_double, ev_quaternion, ev_quaternion, PROG_V6P_VERSION, }, - [OP_MUL_QD_v6p] = {"*", "mul.qd", + [OP_MUL_QD_v6p] = {"mul", "mul.qd", ev_quaternion, ev_double, ev_quaternion, PROG_V6P_VERSION, }, - [OP_MUL_QV_v6p] = {"*", "mul.qv", + [OP_MUL_QV_v6p] = {"mul", "mul.qv", ev_quaternion, ev_vector, ev_vector, PROG_V6P_VERSION, }, - [OP_CONJ_Q_v6p] = {"~", "conj.q", + [OP_CONJ_Q_v6p] = {"conj", "conj.q", ev_quaternion, ev_invalid, ev_quaternion, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_DIV_F_v6p] = {"/", "div.f", + [OP_DIV_F_v6p] = {"div", "div.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_DIV_D_v6p] = {"/", "div.d", + [OP_DIV_D_v6p] = {"div", "div.d", ev_double, ev_double, ev_double, PROG_V6P_VERSION, }, - [OP_REM_D_v6p] = {"%", "rem.d", + [OP_REM_D_v6p] = {"rem", "rem.d", ev_double, ev_double, ev_double, PROG_V6P_VERSION, }, - [OP_MOD_D_v6p] = {"%%", "mod.d", + [OP_MOD_D_v6p] = {"mod", "mod.d", ev_double, ev_double, ev_double, PROG_V6P_VERSION, }, - [OP_ADD_D_v6p] = {"+", "add.d", + [OP_ADD_D_v6p] = {"add", "add.d", ev_double, ev_double, ev_double, PROG_V6P_VERSION, }, - [OP_ADD_F_v6p] = {"+", "add.f", + [OP_ADD_F_v6p] = {"add", "add.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_ADD_V_v6p] = {"+", "add.v", + [OP_ADD_V_v6p] = {"add", "add.v", ev_vector, ev_vector, ev_vector, PROG_ID_VERSION, }, - [OP_ADD_Q_v6p] = {"+", "add.q", + [OP_ADD_Q_v6p] = {"add", "add.q", ev_quaternion, ev_quaternion, ev_quaternion, PROG_V6P_VERSION, }, - [OP_ADD_S_v6p] = {"+", "add.s", + [OP_ADD_S_v6p] = {"add", "add.s", ev_string, ev_string, ev_string, PROG_V6P_VERSION, }, - [OP_SUB_D_v6p] = {"-", "sub.d", + [OP_SUB_D_v6p] = {"sub", "sub.d", ev_double, ev_double, ev_double, PROG_V6P_VERSION, }, - [OP_SUB_F_v6p] = {"-", "sub.f", + [OP_SUB_F_v6p] = {"sub", "sub.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_SUB_V_v6p] = {"-", "sub.v", + [OP_SUB_V_v6p] = {"sub", "sub.v", ev_vector, ev_vector, ev_vector, PROG_ID_VERSION, }, - [OP_SUB_Q_v6p] = {"-", "sub.q", + [OP_SUB_Q_v6p] = {"sub", "sub.q", ev_quaternion, ev_quaternion, ev_quaternion, PROG_V6P_VERSION, }, - [OP_EQ_D_v6p] = {"==", "eq.d", + [OP_EQ_D_v6p] = {"eq", "eq.d", ev_double, ev_double, ev_int, PROG_V6P_VERSION, }, - [OP_EQ_F_v6p] = {"==", "eq.f", + [OP_EQ_F_v6p] = {"eq", "eq.f", ev_float, ev_float, ev_int, PROG_ID_VERSION, }, - [OP_EQ_V_v6p] = {"==", "eq.v", + [OP_EQ_V_v6p] = {"eq", "eq.v", ev_vector, ev_vector, ev_int, PROG_ID_VERSION, }, - [OP_EQ_Q_v6p] = {"==", "eq.q", + [OP_EQ_Q_v6p] = {"eq", "eq.q", ev_quaternion, ev_quaternion, ev_int, PROG_V6P_VERSION, }, - [OP_EQ_S_v6p] = {"==", "eq.s", + [OP_EQ_S_v6p] = {"eq", "eq.s", ev_string, ev_string, ev_int, PROG_ID_VERSION, }, - [OP_EQ_E_v6p] = {"==", "eq.e", + [OP_EQ_E_v6p] = {"eq", "eq.e", ev_entity, ev_entity, ev_int, PROG_ID_VERSION, }, - [OP_EQ_FN_v6p] = {"==", "eq.fn", + [OP_EQ_FN_v6p] = {"eq", "eq.fn", ev_func, ev_func, ev_int, PROG_ID_VERSION, }, - [OP_NE_D_v6p] = {"!=", "ne.d", + [OP_NE_D_v6p] = {"ne", "ne.d", ev_double, ev_double, ev_int, PROG_V6P_VERSION, }, - [OP_NE_F_v6p] = {"!=", "ne.f", + [OP_NE_F_v6p] = {"ne", "ne.f", ev_float, ev_float, ev_int, PROG_ID_VERSION, }, - [OP_NE_V_v6p] = {"!=", "ne.v", + [OP_NE_V_v6p] = {"ne", "ne.v", ev_vector, ev_vector, ev_int, PROG_ID_VERSION, }, - [OP_NE_Q_v6p] = {"!=", "ne.q", + [OP_NE_Q_v6p] = {"ne", "ne.q", ev_quaternion, ev_quaternion, ev_int, PROG_V6P_VERSION, }, - [OP_NE_S_v6p] = {"!=", "ne.s", + [OP_NE_S_v6p] = {"ne", "ne.s", ev_string, ev_string, ev_int, PROG_ID_VERSION, }, - [OP_NE_E_v6p] = {"!=", "ne.e", + [OP_NE_E_v6p] = {"ne", "ne.e", ev_entity, ev_entity, ev_int, PROG_ID_VERSION, }, - [OP_NE_FN_v6p] = {"!=", "ne.fn", + [OP_NE_FN_v6p] = {"ne", "ne.fn", ev_func, ev_func, ev_int, PROG_ID_VERSION, }, - [OP_LE_D_v6p] = {"<=", "le.d", + [OP_LE_D_v6p] = {"le", "le.d", ev_double, ev_double, ev_int, PROG_V6P_VERSION, }, - [OP_LE_F_v6p] = {"<=", "le.f", + [OP_LE_F_v6p] = {"le", "le.f", ev_float, ev_float, ev_int, PROG_ID_VERSION, }, - [OP_GE_D_v6p] = {">=", "ge.d", + [OP_GE_D_v6p] = {"ge", "ge.d", ev_double, ev_double, ev_int, PROG_V6P_VERSION, }, - [OP_GE_F_v6p] = {">=", "ge.f", + [OP_GE_F_v6p] = {"ge", "ge.f", ev_float, ev_float, ev_int, PROG_ID_VERSION, }, - [OP_LE_S_v6p] = {"<=", "le.s", + [OP_LE_S_v6p] = {"le", "le.s", ev_string, ev_string, ev_int, PROG_V6P_VERSION, }, - [OP_GE_S_v6p] = {">=", "ge.s", + [OP_GE_S_v6p] = {"ge", "ge.s", ev_string, ev_string, ev_int, PROG_V6P_VERSION, }, - [OP_LT_D_v6p] = {"<", "lt.d", + [OP_LT_D_v6p] = {"lt", "lt.d", ev_double, ev_double, ev_int, PROG_V6P_VERSION, }, - [OP_LT_F_v6p] = {"<", "lt.f", + [OP_LT_F_v6p] = {"lt", "lt.f", ev_float, ev_float, ev_int, PROG_ID_VERSION, }, - [OP_GT_D_v6p] = {">", "gt.d", + [OP_GT_D_v6p] = {"gt", "gt.d", ev_double, ev_double, ev_int, PROG_V6P_VERSION, }, - [OP_GT_F_v6p] = {">", "gt.f", + [OP_GT_F_v6p] = {"gt", "gt.f", ev_float, ev_float, ev_int, PROG_ID_VERSION, }, - [OP_LT_S_v6p] = {"<", "lt.s", + [OP_LT_S_v6p] = {"lt", "lt.s", ev_string, ev_string, ev_int, PROG_V6P_VERSION, }, - [OP_GT_S_v6p] = {">", "gt.s", + [OP_GT_S_v6p] = {"gt", "gt.s", ev_string, ev_string, ev_int, PROG_V6P_VERSION, }, - [OP_LOAD_F_v6p] = {".", "load.f", + [OP_LOAD_F_v6p] = {"load", "load.f", ev_entity, ev_field, ev_float, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc",//FIXME %E more flexible? }, - [OP_LOAD_D_v6p] = {".", "load.d", + [OP_LOAD_D_v6p] = {"load", "load.d", ev_entity, ev_field, ev_double, PROG_V6P_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_V_v6p] = {".", "load.v", + [OP_LOAD_V_v6p] = {"load", "load.v", ev_entity, ev_field, ev_vector, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_Q_v6p] = {".", "load.q", + [OP_LOAD_Q_v6p] = {"load", "load.q", ev_entity, ev_field, ev_quaternion, PROG_V6P_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_S_v6p] = {".", "load.s", + [OP_LOAD_S_v6p] = {"load", "load.s", ev_entity, ev_field, ev_string, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_ENT_v6p] = {".", "load.ent", + [OP_LOAD_ENT_v6p] = {"load", "load.ent", ev_entity, ev_field, ev_entity, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_FLD_v6p] = {".", "load.fld", + [OP_LOAD_FLD_v6p] = {"load", "load.fld", ev_entity, ev_field, ev_field, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_FN_v6p] = {".", "load.fn", + [OP_LOAD_FN_v6p] = {"load", "load.fn", ev_entity, ev_field, ev_func, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_I_v6p] = {".", "load.i", + [OP_LOAD_I_v6p] = {"load", "load.i", ev_entity, ev_field, ev_int, PROG_V6P_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOAD_P_v6p] = {".", "load.p", + [OP_LOAD_P_v6p] = {"load", "load.p", ev_entity, ev_field, ev_ptr, PROG_V6P_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_LOADB_D_v6p] = {".", "loadb.d", + [OP_LOADB_D_v6p] = {"load", "loadb.d", ev_ptr, ev_int, ev_double, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_F_v6p] = {".", "loadb.f", + [OP_LOADB_F_v6p] = {"load", "loadb.f", ev_ptr, ev_int, ev_float, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_V_v6p] = {".", "loadb.v", + [OP_LOADB_V_v6p] = {"load", "loadb.v", ev_ptr, ev_int, ev_vector, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_Q_v6p] = {".", "loadb.q", + [OP_LOADB_Q_v6p] = {"load", "loadb.q", ev_ptr, ev_int, ev_quaternion, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_S_v6p] = {".", "loadb.s", + [OP_LOADB_S_v6p] = {"load", "loadb.s", ev_ptr, ev_int, ev_string, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_ENT_v6p] = {".", "loadb.ent", + [OP_LOADB_ENT_v6p] = {"load", "loadb.ent", ev_ptr, ev_int, ev_entity, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_FLD_v6p] = {".", "loadb.fld", + [OP_LOADB_FLD_v6p] = {"load", "loadb.fld", ev_ptr, ev_int, ev_field, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_FN_v6p] = {".", "loadb.fn", + [OP_LOADB_FN_v6p] = {"load", "loadb.fn", ev_ptr, ev_int, ev_func, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_I_v6p] = {".", "loadb.i", + [OP_LOADB_I_v6p] = {"load", "loadb.i", ev_ptr, ev_int, ev_int, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADB_P_v6p] = {".", "loadb.p", + [OP_LOADB_P_v6p] = {"load", "loadb.p", ev_ptr, ev_int, ev_ptr, PROG_V6P_VERSION, "*(%Ga + %Gb), %gc", }, - [OP_LOADBI_D_v6p] = {".", "loadbi.d", + [OP_LOADBI_D_v6p] = {"load", "loadbi.d", ev_ptr, ev_short, ev_double, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_F_v6p] = {".", "loadbi.f", + [OP_LOADBI_F_v6p] = {"load", "loadbi.f", ev_ptr, ev_short, ev_float, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_V_v6p] = {".", "loadbi.v", + [OP_LOADBI_V_v6p] = {"load", "loadbi.v", ev_ptr, ev_short, ev_vector, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_Q_v6p] = {".", "loadbi.q", + [OP_LOADBI_Q_v6p] = {"load", "loadbi.q", ev_ptr, ev_short, ev_quaternion, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_S_v6p] = {".", "loadbi.s", + [OP_LOADBI_S_v6p] = {"load", "loadbi.s", ev_ptr, ev_short, ev_string, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_ENT_v6p] = {".", "loadbi.ent", + [OP_LOADBI_ENT_v6p] = {"load", "loadbi.ent", ev_ptr, ev_short, ev_entity, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_FLD_v6p] = {".", "loadbi.fld", + [OP_LOADBI_FLD_v6p] = {"load", "loadbi.fld", ev_ptr, ev_short, ev_field, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_FN_v6p] = {".", "loadbi.fn", + [OP_LOADBI_FN_v6p] = {"load", "loadbi.fn", ev_ptr, ev_short, ev_func, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_I_v6p] = {".", "loadbi.i", + [OP_LOADBI_I_v6p] = {"load", "loadbi.i", ev_ptr, ev_short, ev_int, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, - [OP_LOADBI_P_v6p] = {".", "loadbi.p", + [OP_LOADBI_P_v6p] = {"load", "loadbi.p", ev_ptr, ev_short, ev_ptr, PROG_V6P_VERSION, "*(%Ga + %sb), %gc", }, - [OP_ADDRESS_v6p] = {"&", "address", + [OP_ADDRESS_v6p] = {"lea", "address", ev_entity, ev_field, ev_ptr, PROG_ID_VERSION, "%Ga.%Gb(%Ec), %gc", }, - [OP_ADDRESS_VOID_v6p] = {"&", "address", + [OP_ADDRESS_VOID_v6p] = {"lea", "address", ev_void, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_D_v6p] = {"&", "address.d", + [OP_ADDRESS_D_v6p] = {"lea", "address.d", ev_double, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_F_v6p] = {"&", "address.f", + [OP_ADDRESS_F_v6p] = {"lea", "address.f", ev_float, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_V_v6p] = {"&", "address.v", + [OP_ADDRESS_V_v6p] = {"lea", "address.v", ev_vector, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_Q_v6p] = {"&", "address.q", + [OP_ADDRESS_Q_v6p] = {"lea", "address.q", ev_quaternion, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_S_v6p] = {"&", "address.s", + [OP_ADDRESS_S_v6p] = {"lea", "address.s", ev_string, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_ENT_v6p] = {"&", "address.ent", + [OP_ADDRESS_ENT_v6p] = {"lea", "address.ent", ev_entity, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_FLD_v6p] = {"&", "address.fld", + [OP_ADDRESS_FLD_v6p] = {"lea", "address.fld", ev_field, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_FN_v6p] = {"&", "address.fn", + [OP_ADDRESS_FN_v6p] = {"lea", "address.fn", ev_func, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_I_v6p] = {"&", "address.i", + [OP_ADDRESS_I_v6p] = {"lea", "address.i", ev_int, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_ADDRESS_P_v6p] = {"&", "address.p", + [OP_ADDRESS_P_v6p] = {"lea", "address.p", ev_ptr, ev_invalid, ev_ptr, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_LEA_v6p] = {"&", "lea", + [OP_LEA_v6p] = {"lea", "lea", ev_ptr, ev_int, ev_ptr, PROG_V6P_VERSION, "(%Ga + %Gb), %gc", }, - [OP_LEAI_v6p] = {"&", "leai", + [OP_LEAI_v6p] = {"lea", "leai", ev_ptr, ev_short, ev_ptr, PROG_V6P_VERSION, "(%Ga + %sb), %gc", }, - [OP_CONV_IF_v6p] = {"", "conv.if", + [OP_CONV_IF_v6p] = {"conv", "conv.if", ev_int, ev_invalid, ev_float, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_CONV_FI_v6p] = {"", "conv.fi", + [OP_CONV_FI_v6p] = {"conv", "conv.fi", ev_float, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_CONV_ID_v6p] = {"", "conv.id", + [OP_CONV_ID_v6p] = {"conv", "conv.id", ev_int, ev_invalid, ev_double, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_CONV_DI_v6p] = {"", "conv.di", + [OP_CONV_DI_v6p] = {"conv", "conv.di", ev_double, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_CONV_FD_v6p] = {"", "conv.fd", + [OP_CONV_FD_v6p] = {"conv", "conv.fd", ev_float, ev_invalid, ev_double, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_CONV_DF_v6p] = {"", "conv.df", + [OP_CONV_DF_v6p] = {"conv", "conv.df", ev_double, ev_invalid, ev_float, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_STORE_D_v6p] = {"=", "store.d", + [OP_STORE_D_v6p] = {"assign", "store.d", ev_double, ev_double, ev_invalid, PROG_V6P_VERSION, "%Ga, %gb", }, - [OP_STORE_F_v6p] = {"=", "store.f", + [OP_STORE_F_v6p] = {"assign", "store.f", ev_float, ev_float, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_V_v6p] = {"=", "store.v", + [OP_STORE_V_v6p] = {"assign", "store.v", ev_vector, ev_vector, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_Q_v6p] = {"=", "store.q", + [OP_STORE_Q_v6p] = {"assign", "store.q", ev_quaternion, ev_quaternion, ev_invalid, PROG_V6P_VERSION, "%Ga, %gb", }, - [OP_STORE_S_v6p] = {"=", "store.s", + [OP_STORE_S_v6p] = {"assign", "store.s", ev_string, ev_string, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_ENT_v6p] = {"=", "store.ent", + [OP_STORE_ENT_v6p] = {"assign", "store.ent", ev_entity, ev_entity, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_FLD_v6p] = {"=", "store.fld", + [OP_STORE_FLD_v6p] = {"assign", "store.fld", ev_field, ev_field, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_FN_v6p] = {"=", "store.fn", + [OP_STORE_FN_v6p] = {"assign", "store.fn", ev_func, ev_func, ev_invalid, PROG_ID_VERSION, "%Ga, %gb", }, - [OP_STORE_I_v6p] = {"=", "store.i", + [OP_STORE_I_v6p] = {"assign", "store.i", ev_int, ev_int, ev_invalid, PROG_V6P_VERSION, "%Ga, %gb", }, - [OP_STORE_P_v6p] = {"=", "store.p", + [OP_STORE_P_v6p] = {"assign", "store.p", ev_ptr, ev_ptr, ev_invalid, PROG_V6P_VERSION, "%Ga, %gb", }, - [OP_STOREP_D_v6p] = {".=", "storep.d", + [OP_STOREP_D_v6p] = {"store", "storep.d", ev_double, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_F_v6p] = {".=", "storep.f", + [OP_STOREP_F_v6p] = {"store", "storep.f", ev_float, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_V_v6p] = {".=", "storep.v", + [OP_STOREP_V_v6p] = {"store", "storep.v", ev_vector, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_Q_v6p] = {".=", "storep.q", + [OP_STOREP_Q_v6p] = {"store", "storep.q", ev_quaternion, ev_ptr, ev_invalid, PROG_V6P_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_S_v6p] = {".=", "storep.s", + [OP_STOREP_S_v6p] = {"store", "storep.s", ev_string, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_ENT_v6p] = {".=", "storep.ent", + [OP_STOREP_ENT_v6p] = {"store", "storep.ent", ev_entity, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_FLD_v6p] = {".=", "storep.fld", + [OP_STOREP_FLD_v6p] = {"store", "storep.fld", ev_field, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_FN_v6p] = {".=", "storep.fn", + [OP_STOREP_FN_v6p] = {"store", "storep.fn", ev_func, ev_ptr, ev_invalid, PROG_ID_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_I_v6p] = {".=", "storep.i", + [OP_STOREP_I_v6p] = {"store", "storep.i", ev_int, ev_ptr, ev_invalid, PROG_V6P_VERSION, "%Ga, *%Gb", }, - [OP_STOREP_P_v6p] = {".=", "storep.p", + [OP_STOREP_P_v6p] = {"store", "storep.p", ev_ptr, ev_ptr, ev_invalid, PROG_V6P_VERSION, "%Ga, *%Gb", }, - [OP_STOREB_D_v6p] = {".=", "storeb.d", + [OP_STOREB_D_v6p] = {"store", "storeb.d", ev_double, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_F_v6p] = {".=", "storeb.f", + [OP_STOREB_F_v6p] = {"store", "storeb.f", ev_float, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_V_v6p] = {".=", "storeb.v", + [OP_STOREB_V_v6p] = {"store", "storeb.v", ev_vector, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_Q_v6p] = {".=", "storeb.q", + [OP_STOREB_Q_v6p] = {"store", "storeb.q", ev_quaternion, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_S_v6p] = {".=", "storeb.s", + [OP_STOREB_S_v6p] = {"store", "storeb.s", ev_string, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_ENT_v6p] = {".=", "storeb.ent", + [OP_STOREB_ENT_v6p] = {"store", "storeb.ent", ev_entity, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_FLD_v6p] = {".=", "storeb.fld", + [OP_STOREB_FLD_v6p] = {"store", "storeb.fld", ev_field, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_FN_v6p] = {".=", "storeb.fn", + [OP_STOREB_FN_v6p] = {"store", "storeb.fn", ev_func, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_I_v6p] = {".=", "storeb.i", + [OP_STOREB_I_v6p] = {"store", "storeb.i", ev_int, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREB_P_v6p] = {".=", "storeb.p", + [OP_STOREB_P_v6p] = {"store", "storeb.p", ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, "%Ga, *(%Gb + %Gc)", }, - [OP_STOREBI_D_v6p] = {".=", "storebi.d", + [OP_STOREBI_D_v6p] = {"store", "storebi.d", ev_double, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_F_v6p] = {".=", "storebi.f", + [OP_STOREBI_F_v6p] = {"store", "storebi.f", ev_float, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_V_v6p] = {".=", "storebi.v", + [OP_STOREBI_V_v6p] = {"store", "storebi.v", ev_vector, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_Q_v6p] = {".=", "storebi.q", + [OP_STOREBI_Q_v6p] = {"store", "storebi.q", ev_quaternion, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_S_v6p] = {".=", "storebi.s", + [OP_STOREBI_S_v6p] = {"store", "storebi.s", ev_string, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_ENT_v6p] = {".=", "storebi.ent", + [OP_STOREBI_ENT_v6p] = {"store", "storebi.ent", ev_entity, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_FLD_v6p] = {".=", "storebi.fld", + [OP_STOREBI_FLD_v6p] = {"store", "storebi.fld", ev_field, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_FN_v6p] = {".=", "storebi.fn", + [OP_STOREBI_FN_v6p] = {"store", "storebi.fn", ev_func, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_I_v6p] = {".=", "storebi.i", + [OP_STOREBI_I_v6p] = {"store", "storebi.i", ev_int, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_STOREBI_P_v6p] = {".=", "storebi.p", + [OP_STOREBI_P_v6p] = {"store", "storebi.p", ev_ptr, ev_ptr, ev_short, PROG_V6P_VERSION, "%Ga, *(%Gb + %sc)", }, - [OP_RETURN_v6p] = {"", "return", + [OP_RETURN_v6p] = {"return", "return", ev_void, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Ra", }, - [OP_RETURN_V_v6p] = {"", "return", + [OP_RETURN_V_v6p] = {"return_v", "return", ev_invalid, ev_invalid, ev_invalid, PROG_V6P_VERSION, "", }, - [OP_NOT_D_v6p] = {"!", "not.d", + [OP_NOT_D_v6p] = {"not", "not.d", ev_double, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_NOT_F_v6p] = {"!", "not.f", + [OP_NOT_F_v6p] = {"not", "not.f", ev_float, ev_invalid, ev_int, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_V_v6p] = {"!", "not.v", + [OP_NOT_V_v6p] = {"not", "not.v", ev_vector, ev_invalid, ev_int, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_Q_v6p] = {"!", "not.q", + [OP_NOT_Q_v6p] = {"not", "not.q", ev_quaternion, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_NOT_S_v6p] = {"!", "not.s", + [OP_NOT_S_v6p] = {"not", "not.s", ev_string, ev_invalid, ev_int, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_ENT_v6p] = {"!", "not.ent", + [OP_NOT_ENT_v6p] = {"not", "not.ent", ev_entity, ev_invalid, ev_int, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_FN_v6p] = {"!", "not.fn", + [OP_NOT_FN_v6p] = {"not", "not.fn", ev_func, ev_invalid, ev_int, PROG_ID_VERSION, "%Ga, %gc", }, - [OP_NOT_P_v6p] = {"!", "not.p", + [OP_NOT_P_v6p] = {"not", "not.p", ev_ptr, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_IF_v6p] = {"", "if", + [OP_IF_v6p] = {"if", "if", ev_int, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFNOT_v6p] = {"", "ifnot", + [OP_IFNOT_v6p] = {"ifnot", "ifnot", ev_int, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFBE_v6p] = {"", "ifbe", + [OP_IFBE_v6p] = {"ifbe", "ifbe", ev_int, ev_short, ev_invalid, PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFB_v6p] = {"", "ifb", + [OP_IFB_v6p] = {"ifb", "ifb", ev_int, ev_short, ev_invalid, PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFAE_v6p] = {"", "ifae", + [OP_IFAE_v6p] = {"ifae", "ifae", ev_int, ev_short, ev_invalid, PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFA_v6p] = {"", "ifa", + [OP_IFA_v6p] = {"ifa", "ifa", ev_int, ev_short, ev_invalid, PROG_V6P_VERSION, "%Ga branch %sb (%Ob)", }, // calls returns REG_RETURN - [OP_CALL0_v6p] = {"", "call0", + [OP_CALL0_v6p] = {"call0", "call0", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa ()", }, - [OP_CALL1_v6p] = {"", "call1", + [OP_CALL1_v6p] = {"call1", "call1", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x)", }, - [OP_CALL2_v6p] = {"", "call2", + [OP_CALL2_v6p] = {"call2", "call2", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x)", }, - [OP_CALL3_v6p] = {"", "call3", + [OP_CALL3_v6p] = {"call3", "call3", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x)", }, - [OP_CALL4_v6p] = {"", "call4", + [OP_CALL4_v6p] = {"call4", "call4", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x)", }, - [OP_CALL5_v6p] = {"", "call5", + [OP_CALL5_v6p] = {"call5", "call5", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x)", }, - [OP_CALL6_v6p] = {"", "call6", + [OP_CALL6_v6p] = {"call6", "call6", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x)", }, - [OP_CALL7_v6p] = {"", "call7", + [OP_CALL7_v6p] = {"call7", "call7", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x, %P6x)", }, - [OP_CALL8_v6p] = {"", "call8", + [OP_CALL8_v6p] = {"call8", "call8", ev_func, ev_invalid, ev_invalid, PROG_ID_VERSION, "%Fa (%P0x, %P1x, %P2x, %P3x, %P4x, %P5x, %P6x, %P7x)", }, - [OP_RCALL0_v6p] = {"", 0, + [OP_RCALL0_v6p] = {"rcall0", 0, ev_invalid, ev_invalid, ev_invalid, ~0, // not a valid instruction 0, }, - [OP_RCALL1_v6p] = {"", "rcall1", + [OP_RCALL1_v6p] = {"rcall1", "rcall1", ev_func, ev_void, ev_invalid, PROG_V6P_VERSION, "%Fa (%P0b)", }, - [OP_RCALL2_v6p] = {"", "rcall2", + [OP_RCALL2_v6p] = {"rcall2", "rcall2", ev_func, ev_void, ev_void, PROG_V6P_VERSION, "%Fa (%P0b, %P1c)", }, - [OP_RCALL3_v6p] = {"", "rcall3", + [OP_RCALL3_v6p] = {"rcall3", "rcall3", ev_func, ev_void, ev_void, PROG_V6P_VERSION, "%Fa (%P0b, %P1c, %P2x)", }, - [OP_RCALL4_v6p] = {"", "rcall4", + [OP_RCALL4_v6p] = {"rcall4", "rcall4", ev_func, ev_void, ev_void, PROG_V6P_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x)", }, - [OP_RCALL5_v6p] = {"", "rcall5", + [OP_RCALL5_v6p] = {"rcall5", "rcall5", ev_func, ev_void, ev_void, PROG_V6P_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x)", }, - [OP_RCALL6_v6p] = {"", "rcall6", + [OP_RCALL6_v6p] = {"rcall6", "rcall6", ev_func, ev_void, ev_void, PROG_V6P_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x)", }, - [OP_RCALL7_v6p] = {"", "rcall7", + [OP_RCALL7_v6p] = {"rcall7", "rcall7", ev_func, ev_void, ev_void, PROG_V6P_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x)", }, - [OP_RCALL8_v6p] = {"", "rcall8", + [OP_RCALL8_v6p] = {"rcall8", "rcall8", ev_func, ev_void, ev_void, PROG_V6P_VERSION, "%Fa (%P0b, %P1c, %P2x, %P3x, %P4x, %P5x, %P6x, %P7x)", }, - [OP_STATE_v6p] = {"", "state", + [OP_STATE_v6p] = {"state", "state", ev_float, ev_func, ev_invalid, PROG_ID_VERSION, "%Ga, %Gb", }, - [OP_STATE_F_v6p] = {"", "state.f", + [OP_STATE_F_v6p] = {"state", "state.f", ev_float, ev_func, ev_float, PROG_V6P_VERSION, "%Ga, %Gb, %Gc", }, - [OP_GOTO_v6p] = {"", "goto", + [OP_GOTO_v6p] = {"jump", "goto", ev_short, ev_invalid, ev_invalid, PROG_ID_VERSION, "branch %sa (%Oa)", }, - [OP_JUMP_v6p] = {"", "jump", + [OP_JUMP_v6p] = {"jump", "jump", ev_int, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, - [OP_JUMPB_v6p] = {"", "jumpb", + [OP_JUMPB_v6p] = {"jumpb", "jumpb", ev_void, ev_int, ev_invalid, PROG_V6P_VERSION, "%Ga[%Gb]", }, - [OP_AND_v6p] = {"&&", "and.f", + [OP_AND_v6p] = {"and", "and.f", ev_float, ev_float, ev_int, PROG_ID_VERSION, }, - [OP_OR_v6p] = {"||", "or.f", + [OP_OR_v6p] = {"or", "or.f", ev_float, ev_float, ev_int, PROG_ID_VERSION, }, - [OP_SHL_F_v6p] = {"<<", "shl.f", + [OP_SHL_F_v6p] = {"shl", "shl.f", ev_float, ev_float, ev_float, PROG_V6P_VERSION, }, - [OP_SHR_F_v6p] = {">>", "shr.f", + [OP_SHR_F_v6p] = {"shr", "shr.f", ev_float, ev_float, ev_float, PROG_V6P_VERSION, }, - [OP_SHL_I_v6p] = {"<<", "shl.i", + [OP_SHL_I_v6p] = {"shl", "shl.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_SHR_I_v6p] = {">>", "shr.i", + [OP_SHR_I_v6p] = {"shr", "shr.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_SHR_U_v6p] = {">>", "shr.u", + [OP_SHR_U_v6p] = {"shr", "shr.u", ev_uint, ev_int, ev_uint, PROG_V6P_VERSION, }, - [OP_BITAND_v6p] = {"&", "bitand", + [OP_BITAND_v6p] = {"bitand", "bitand.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_BITOR_v6p] = {"|", "bitor", + [OP_BITOR_v6p] = {"bitor", "bitor.f", ev_float, ev_float, ev_float, PROG_ID_VERSION, }, - [OP_ADD_I_v6p] = {"+", "add.i", + [OP_ADD_I_v6p] = {"add", "add.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_SUB_I_v6p] = {"-", "sub.i", + [OP_SUB_I_v6p] = {"sub", "sub.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_MUL_I_v6p] = {"*", "mul.i", + [OP_MUL_I_v6p] = {"mul", "mul.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_DIV_I_v6p] = {"/", "div.i", + [OP_DIV_I_v6p] = {"div", "div.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_REM_I_v6p] = {"%", "rem.i", + [OP_REM_I_v6p] = {"rem", "rem.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_MOD_I_v6p] = {"%%", "mod.i", + [OP_MOD_I_v6p] = {"mod", "mod.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_BITAND_I_v6p] = {"&", "bitand.i", + [OP_BITAND_I_v6p] = {"bitand", "bitand.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_BITOR_I_v6p] = {"|", "bitor.i", + [OP_BITOR_I_v6p] = {"bitor", "bitor.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_REM_F_v6p] = {"%", "rem.f", + [OP_REM_F_v6p] = {"rem", "rem.f", ev_float, ev_float, ev_float, PROG_V6P_VERSION, }, - [OP_MOD_F_v6p] = {"%%", "mod.f", + [OP_MOD_F_v6p] = {"mod", "mod.f", ev_float, ev_float, ev_float, PROG_V6P_VERSION, }, - [OP_GE_I_v6p] = {">=", "ge.i", + [OP_GE_I_v6p] = {"ge", "ge.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_LE_I_v6p] = {"<=", "le.i", + [OP_LE_I_v6p] = {"le", "le.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_GT_I_v6p] = {">", "gt.i", + [OP_GT_I_v6p] = {"gt", "gt.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_LT_I_v6p] = {"<", "lt.i", + [OP_LT_I_v6p] = {"lt", "lt.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_AND_I_v6p] = {"&&", "and.i", + [OP_AND_I_v6p] = {"and", "and.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_OR_I_v6p] = {"||", "or.i", + [OP_OR_I_v6p] = {"or", "or.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_NOT_I_v6p] = {"!", "not.i", + [OP_NOT_I_v6p] = {"not", "not.i", ev_int, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_EQ_I_v6p] = {"==", "eq.i", + [OP_EQ_I_v6p] = {"eq", "eq.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_NE_I_v6p] = {"!=", "ne.i", + [OP_NE_I_v6p] = {"ne", "ne.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_GE_U_v6p] = {">=", "ge.u", + [OP_GE_U_v6p] = {"ge", "ge.u", ev_uint, ev_uint, ev_int, PROG_V6P_VERSION, }, - [OP_LE_U_v6p] = {"<=", "le.u", + [OP_LE_U_v6p] = {"le", "le.u", ev_uint, ev_uint, ev_int, PROG_V6P_VERSION, }, - [OP_GT_U_v6p] = {">", "gt.u", + [OP_GT_U_v6p] = {"gt", "gt.u", ev_uint, ev_uint, ev_int, PROG_V6P_VERSION, }, - [OP_LT_U_v6p] = {"<", "lt.u", + [OP_LT_U_v6p] = {"lt", "lt.u", ev_uint, ev_uint, ev_int, PROG_V6P_VERSION, }, - [OP_BITXOR_F_v6p] = {"^", "bitxor.f", + [OP_BITXOR_F_v6p] = {"bitxor", "bitxor.f", ev_float, ev_float, ev_float, PROG_V6P_VERSION, }, - [OP_BITNOT_F_v6p] = {"~", "bitnot.f", + [OP_BITNOT_F_v6p] = {"bitnot", "bitnot.f", ev_float, ev_invalid, ev_float, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_BITXOR_I_v6p] = {"^", "bitxor.i", + [OP_BITXOR_I_v6p] = {"bitxor", "bitxor.i", ev_int, ev_int, ev_int, PROG_V6P_VERSION, }, - [OP_BITNOT_I_v6p] = {"~", "bitnot.i", + [OP_BITNOT_I_v6p] = {"bitnot", "bitnot.i", ev_int, ev_invalid, ev_int, PROG_V6P_VERSION, "%Ga, %gc", }, - [OP_GE_P_v6p] = {">=", "ge.p", + [OP_GE_P_v6p] = {"ge", "ge.p", ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, }, - [OP_LE_P_v6p] = {"<=", "le.p", + [OP_LE_P_v6p] = {"le", "le.p", ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, }, - [OP_GT_P_v6p] = {">", "gt.p", + [OP_GT_P_v6p] = {"gt", "gt.p", ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, }, - [OP_LT_P_v6p] = {"<", "lt.p", + [OP_LT_P_v6p] = {"lt", "lt.p", ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, }, - [OP_EQ_P_v6p] = {"==", "eq.p", + [OP_EQ_P_v6p] = {"eq", "eq.p", ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, }, - [OP_NE_P_v6p] = {"!=", "ne.p", + [OP_NE_P_v6p] = {"ne", "ne.p", ev_ptr, ev_ptr, ev_int, PROG_V6P_VERSION, }, - [OP_MOVEI_v6p] = {"", "movei", + [OP_MOVEI_v6p] = {"move", "movei", ev_void, ev_short, ev_void, PROG_V6P_VERSION, "%Ga, %sb, %gc", }, - [OP_MOVEP_v6p] = {"", "movep", + [OP_MOVEP_v6p] = {"movep", "movep", ev_ptr, ev_int, ev_ptr, PROG_V6P_VERSION, "%Ga, %Gb, %Gc", }, - [OP_MOVEPI_v6p] = {"", "movepi", + [OP_MOVEPI_v6p] = {"movep", "movepi", ev_ptr, ev_short, ev_ptr, PROG_V6P_VERSION, "%Ga, %sb, %Gc", }, - [OP_MEMSETI_v6p] = {"", "memseti", + [OP_MEMSETI_v6p] = {"memset", "memseti", ev_int, ev_short, ev_void, PROG_V6P_VERSION, "%Ga, %sb, %gc", }, - [OP_MEMSETP_v6p] = {"", "memsetp", + [OP_MEMSETP_v6p] = {"memsetp", "memsetp", ev_int, ev_int, ev_ptr, PROG_V6P_VERSION, "%Ga, %Gb, %Gc", }, - [OP_MEMSETPI_v6p] = {"", "memsetpi", + [OP_MEMSETPI_v6p] = {"memsetp", "memsetpi", ev_int, ev_short, ev_ptr, PROG_V6P_VERSION, "%Ga, %sb, %Gc", }, - [OP_PUSH_S_v6p] = {"", "push.s", + [OP_PUSH_S_v6p] = {"push", "push.s", ev_string, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, - [OP_PUSH_F_v6p] = {"", "push.f", + [OP_PUSH_F_v6p] = {"push", "push.f", ev_float, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, - [OP_PUSH_V_v6p] = {"", "push.v", + [OP_PUSH_V_v6p] = {"push", "push.v", ev_vector, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, - [OP_PUSH_ENT_v6p] = {"", "push.ent", + [OP_PUSH_ENT_v6p] = {"push", "push.ent", ev_entity, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, - [OP_PUSH_FLD_v6p] = {"", "push.fld", + [OP_PUSH_FLD_v6p] = {"push", "push.fld", ev_field, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, - [OP_PUSH_FN_v6p] = {"", "push.fn", + [OP_PUSH_FN_v6p] = {"push", "push.fn", ev_func, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, - [OP_PUSH_P_v6p] = {"", "push.p", + [OP_PUSH_P_v6p] = {"push", "push.p", ev_ptr, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, - [OP_PUSH_Q_v6p] = {"", "push.q", + [OP_PUSH_Q_v6p] = {"push", "push.q", ev_quaternion, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, - [OP_PUSH_I_v6p] = {"", "push.i", + [OP_PUSH_I_v6p] = {"push", "push.i", ev_int, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, - [OP_PUSH_D_v6p] = {"", "push.d", + [OP_PUSH_D_v6p] = {"push", "push.d", ev_double, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%Ga", }, - [OP_PUSHB_S_v6p] = {"", "pushb.s", + [OP_PUSHB_S_v6p] = {"push", "pushb.s", ev_ptr, ev_int, ev_string, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_F_v6p] = {"", "pushb.f", + [OP_PUSHB_F_v6p] = {"push", "pushb.f", ev_ptr, ev_int, ev_float, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_V_v6p] = {"", "pushb.v", + [OP_PUSHB_V_v6p] = {"push", "pushb.v", ev_ptr, ev_int, ev_vector, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_ENT_v6p] = {"", "pushb.ent", + [OP_PUSHB_ENT_v6p] = {"push", "pushb.ent", ev_ptr, ev_int, ev_entity, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_FLD_v6p] = {"", "pushb.fld", + [OP_PUSHB_FLD_v6p] = {"push", "pushb.fld", ev_ptr, ev_int, ev_field, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_FN_v6p] = {"", "pushb.fn", + [OP_PUSHB_FN_v6p] = {"push", "pushb.fn", ev_ptr, ev_int, ev_func, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_P_v6p] = {"", "pushb.p", + [OP_PUSHB_P_v6p] = {"push", "pushb.p", ev_ptr, ev_int, ev_ptr, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_Q_v6p] = {"", "pushb.q", + [OP_PUSHB_Q_v6p] = {"push", "pushb.q", ev_ptr, ev_int, ev_quaternion, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_I_v6p] = {"", "pushb.i", + [OP_PUSHB_I_v6p] = {"push", "pushb.i", ev_ptr, ev_int, ev_int, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHB_D_v6p] = {"", "pushb.d", + [OP_PUSHB_D_v6p] = {"push", "pushb.d", ev_ptr, ev_int, ev_double, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_PUSHBI_S_v6p] = {"", "pushbi.s", + [OP_PUSHBI_S_v6p] = {"push", "pushbi.s", ev_ptr, ev_short, ev_string, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_F_v6p] = {"", "pushbi.f", + [OP_PUSHBI_F_v6p] = {"push", "pushbi.f", ev_ptr, ev_short, ev_float, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_V_v6p] = {"", "pushbi.v", + [OP_PUSHBI_V_v6p] = {"push", "pushbi.v", ev_ptr, ev_short, ev_vector, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_ENT_v6p] = {"", "pushbi.ent", + [OP_PUSHBI_ENT_v6p] = {"push", "pushbi.ent", ev_ptr, ev_short, ev_entity, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_FLD_v6p] = {"", "pushbi.fld", + [OP_PUSHBI_FLD_v6p] = {"push", "pushbi.fld", ev_ptr, ev_short, ev_field, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_FN_v6p] = {"", "pushbi.fn", + [OP_PUSHBI_FN_v6p] = {"push", "pushbi.fn", ev_ptr, ev_short, ev_func, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_P_v6p] = {"", "pushbi.p", + [OP_PUSHBI_P_v6p] = {"push", "pushbi.p", ev_ptr, ev_short, ev_ptr, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_Q_v6p] = {"", "pushbi.q", + [OP_PUSHBI_Q_v6p] = {"push", "pushbi.q", ev_ptr, ev_short, ev_quaternion, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_I_v6p] = {"", "pushbi.i", + [OP_PUSHBI_I_v6p] = {"push", "pushbi.i", ev_ptr, ev_short, ev_int, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_PUSHBI_D_v6p] = {"", "pushbi.d", + [OP_PUSHBI_D_v6p] = {"push", "pushbi.d", ev_ptr, ev_short, ev_double, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_POP_S_v6p] = {"", "pop.s", + [OP_POP_S_v6p] = {"pop", "pop.s", ev_string, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%ga", }, - [OP_POP_F_v6p] = {"", "pop.f", + [OP_POP_F_v6p] = {"pop", "pop.f", ev_float, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%ga", }, - [OP_POP_V_v6p] = {"", "pop.v", + [OP_POP_V_v6p] = {"pop", "pop.v", ev_vector, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%ga", }, - [OP_POP_ENT_v6p] = {"", "pop.ent", + [OP_POP_ENT_v6p] = {"pop", "pop.ent", ev_entity, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%ga", }, - [OP_POP_FLD_v6p] = {"", "pop.fld", + [OP_POP_FLD_v6p] = {"pop", "pop.fld", ev_field, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%ga", }, - [OP_POP_FN_v6p] = {"", "pop.fn", + [OP_POP_FN_v6p] = {"pop", "pop.fn", ev_func, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%ga", }, - [OP_POP_P_v6p] = {"", "pop.p", + [OP_POP_P_v6p] = {"pop", "pop.p", ev_ptr, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%ga", }, - [OP_POP_Q_v6p] = {"", "pop.q", + [OP_POP_Q_v6p] = {"pop", "pop.q", ev_quaternion, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%ga", }, - [OP_POP_I_v6p] = {"", "pop.i", + [OP_POP_I_v6p] = {"pop", "pop.i", ev_int, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%ga", }, - [OP_POP_D_v6p] = {"", "pop.d", + [OP_POP_D_v6p] = {"pop", "pop.d", ev_double, ev_invalid, ev_invalid, PROG_V6P_VERSION, "%ga", }, - [OP_POPB_S_v6p] = {"", "popb.s", + [OP_POPB_S_v6p] = {"pop", "popb.s", ev_ptr, ev_int, ev_string, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_F_v6p] = {"", "popb.f", + [OP_POPB_F_v6p] = {"pop", "popb.f", ev_ptr, ev_int, ev_float, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_V_v6p] = {"", "popb.v", + [OP_POPB_V_v6p] = {"pop", "popb.v", ev_ptr, ev_int, ev_vector, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_ENT_v6p] = {"", "popb.ent", + [OP_POPB_ENT_v6p] = {"pop", "popb.ent", ev_ptr, ev_int, ev_entity, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_FLD_v6p] = {"", "popb.fld", + [OP_POPB_FLD_v6p] = {"pop", "popb.fld", ev_ptr, ev_int, ev_field, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_FN_v6p] = {"", "popb.fn", + [OP_POPB_FN_v6p] = {"pop", "popb.fn", ev_ptr, ev_int, ev_func, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_P_v6p] = {"", "popb.p", + [OP_POPB_P_v6p] = {"pop", "popb.p", ev_ptr, ev_int, ev_ptr, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_Q_v6p] = {"", "popb.q", + [OP_POPB_Q_v6p] = {"pop", "popb.q", ev_ptr, ev_int, ev_quaternion, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_I_v6p] = {"", "popb.i", + [OP_POPB_I_v6p] = {"pop", "popb.i", ev_ptr, ev_int, ev_int, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_POPB_D_v6p] = {"", "popb.d", + [OP_POPB_D_v6p] = {"pop", "popb.d", ev_ptr, ev_int, ev_double, PROG_V6P_VERSION, "*(%Ga + %Gb)", }, - [OP_POPBI_S_v6p] = {"", "popbi.s", + [OP_POPBI_S_v6p] = {"pop", "popbi.s", ev_ptr, ev_short, ev_string, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_F_v6p] = {"", "popbi.f", + [OP_POPBI_F_v6p] = {"pop", "popbi.f", ev_ptr, ev_short, ev_float, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_V_v6p] = {"", "popbi.v", + [OP_POPBI_V_v6p] = {"pop", "popbi.v", ev_ptr, ev_short, ev_vector, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_ENT_v6p] = {"", "popbi.ent", + [OP_POPBI_ENT_v6p] = {"pop", "popbi.ent", ev_ptr, ev_short, ev_entity, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_FLD_v6p] = {"", "popbi.fld", + [OP_POPBI_FLD_v6p] = {"pop", "popbi.fld", ev_ptr, ev_short, ev_field, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_FN_v6p] = {"", "popbi.fn", + [OP_POPBI_FN_v6p] = {"pop", "popbi.fn", ev_ptr, ev_short, ev_func, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_P_v6p] = {"", "popbi.p", + [OP_POPBI_P_v6p] = {"pop", "popbi.p", ev_ptr, ev_short, ev_ptr, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_Q_v6p] = {"", "popbi.q", + [OP_POPBI_Q_v6p] = {"pop", "popbi.q", ev_ptr, ev_short, ev_quaternion, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_I_v6p] = {"", "popbi.i", + [OP_POPBI_I_v6p] = {"pop", "popbi.i", ev_ptr, ev_short, ev_int, PROG_V6P_VERSION, "*(%Ga + %sb)", }, - [OP_POPBI_D_v6p] = {"", "popbi.d", + [OP_POPBI_D_v6p] = {"pop", "popbi.d", ev_ptr, ev_short, ev_double, PROG_V6P_VERSION, "*(%Ga + %sb)", @@ -1625,7 +1625,7 @@ PR_Check_Opcodes (progs_t *pr) PR_Error (pr, "PR_Check_Opcodes: %s used with missing fields " "or globals", op->opname); } - if ((strequal(op->name, "") || strequal(op->name, "")) + if ((strequal(op->name, "push") || strequal(op->name, "pop")) && !pushpop_ok) { PR_Error (pr, "PR_Check_Opcodes: %s used with missing .stack " "globals", op->opname); diff --git a/tools/qfcc/source/dags.c b/tools/qfcc/source/dags.c index 9c7746bea..3040c5425 100644 --- a/tools/qfcc/source/dags.c +++ b/tools/qfcc/source/dags.c @@ -327,8 +327,8 @@ dagnode_match (const dagnode_t *n, const daglabel_t *op, if (n->killed) return 0; - if (!strcmp (op->opcode, ".") - && n->label->opcode && !strcmp (n->label->opcode, ".=")) + if (!strcmp (op->opcode, "load") + && n->label->opcode && !strcmp (n->label->opcode, "store")) return dagnode_deref_match (n, op, children); if (n->label->opcode != op->opcode) return 0; @@ -452,12 +452,12 @@ dagnode_set_edges (dag_t *dag, dagnode_t *n) int first_param = 0; flowvar_t **flowvars = dag->flownode->graph->func->vars; - if (!strncmp (n->label->opcode, "label->opcode, "rcall", 5)) { num_params = n->label->opcode + 6; first_param = 2; - } else if (!strncmp (n->label->opcode, "label->opcode, "call", 4)) { num_params = n->label->opcode + 5; - } else if (!strcmp (n->label->opcode, "")) { + } else if (!strcmp (n->label->opcode, "return")) { daglabel_t *label = n->children[0]->label; if (!label->op) { set_iter_t *lab_i; @@ -997,7 +997,7 @@ generate_moves (dag_t *dag, sblock_t *block, dagnode_t *dagnode) var = dag->labels[var_iter->element]; operands[2] = var->op; dst = operands[2]; - st = build_statement ("", operands, var->expr); + st = build_statement ("move", operands, var->expr); sblock_add_statement (block, st); } return dst; @@ -1019,7 +1019,7 @@ generate_moveps (dag_t *dag, sblock_t *block, dagnode_t *dagnode) operands[1] = make_operand (dag, block, dagnode, 1); if (dagnode->children[2]) { operands[2] = make_operand (dag, block, dagnode, 2); - st = build_statement ("", operands, dagnode->label->expr); + st = build_statement ("movep", operands, dagnode->label->expr); sblock_add_statement (block, st); if ((var_iter = set_first (dagnode->identifiers))) { var = dag->labels[var_iter->element]; @@ -1039,7 +1039,7 @@ generate_moveps (dag_t *dag, sblock_t *block, dagnode_t *dagnode) } operands[2] = value_operand (new_pointer_val (offset, type, dstDef, 0), operands[1]->expr); - st = build_statement ("", operands, var->expr); + st = build_statement ("movep", operands, var->expr); sblock_add_statement (block, st); } } @@ -1063,7 +1063,7 @@ generate_memsets (dag_t *dag, sblock_t *block, dagnode_t *dagnode) var = dag->labels[var_iter->element]; operands[2] = var->op; dst = operands[2]; - st = build_statement ("", operands, var->expr); + st = build_statement ("memset", operands, var->expr); sblock_add_statement (block, st); } return dst; @@ -1085,7 +1085,7 @@ generate_memsetps (dag_t *dag, sblock_t *block, dagnode_t *dagnode) operands[1] = make_operand (dag, block, dagnode, 1); if (dagnode->children[2]) { operands[2] = make_operand (dag, block, dagnode, 2); - st = build_statement ("", operands, dagnode->label->expr); + st = build_statement ("memsetp", operands, dagnode->label->expr); sblock_add_statement (block, st); } else { for (var_iter = set_first (dagnode->identifiers); var_iter; @@ -1100,7 +1100,7 @@ generate_memsetps (dag_t *dag, sblock_t *block, dagnode_t *dagnode) } operands[2] = value_operand (new_pointer_val (offset, type, dstDef, 0), operands[1]->expr); - st = build_statement ("", operands, var->expr); + st = build_statement ("memsetp", operands, var->expr); sblock_add_statement (block, st); } } @@ -1123,7 +1123,7 @@ generate_assignments (dag_t *dag, sblock_t *block, operand_t *src, if (!dst) dst = operands[1]; - st = build_statement ("=", operands, var->expr); + st = build_statement ("assign", operands, var->expr); sblock_add_statement (block, st); } return dst; diff --git a/tools/qfcc/source/flow.c b/tools/qfcc/source/flow.c index 8edc44ad1..d713b1ce8 100644 --- a/tools/qfcc/source/flow.c +++ b/tools/qfcc/source/flow.c @@ -1205,20 +1205,20 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, case st_ptrmemset: flow_add_op_var (use, s->opa, 1); flow_add_op_var (use, s->opb, 1); - if (!strcmp (s->opcode, "") - || !strcmp (s->opcode, "")) { + if (!strcmp (s->opcode, "move") + || !strcmp (s->opcode, "memset")) { flow_add_op_var (def, s->opc, 0); res_op = s->opc; - } else if (!strcmp (s->opcode, "")) { + } else if (!strcmp (s->opcode, "movep")) { flow_add_op_var (use, s->opc, 0); aux_op2 = flow_analyze_pointer_operand (s->opa, use); res_op = flow_analyze_pointer_operand (s->opc, def); aux_op1 = s->opc; - } else if (!strcmp (s->opcode, "")) { + } else if (!strcmp (s->opcode, "memsetp")) { flow_add_op_var (use, s->opc, 0); res_op = flow_analyze_pointer_operand (s->opc, def); aux_op1 = s->opc; - } else if (!strcmp (s->opcode, ".=")) { + } else if (!strcmp (s->opcode, "store")) { flow_add_op_var (use, s->opc, 1); res_op = flow_analyze_pointer_operand (s->opb, def); aux_op1 = s->opc; @@ -1250,19 +1250,19 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, } break; case st_func: - if (strcmp (s->opcode, "") == 0 - || strcmp (s->opcode, "") == 0) { + if (strcmp (s->opcode, "return") == 0 + || strcmp (s->opcode, "done") == 0) { flow_add_op_var (use, s->opa, 1); - } else if (strcmp (s->opcode, "") == 0) { + } else if (strcmp (s->opcode, "return_v") == 0) { if (use) { flow_add_op_var (use, &flow_params[0].op, 1); } } - if (strncmp (s->opcode, "opcode, "call", 4) == 0) { start = 0; calln = s->opcode[5] - '0'; flow_add_op_var (use, s->opa, 1); - } else if (strncmp (s->opcode, "opcode, "rcall", 5) == 0) { start = 2; calln = s->opcode[6] - '0'; flow_add_op_var (use, s->opa, 1); @@ -1296,9 +1296,9 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, } break; case st_flow: - if (strcmp (s->opcode, "") != 0) { + if (strcmp (s->opcode, "jump") != 0) { flow_add_op_var (use, s->opa, 1); - if (strcmp (s->opcode, "") == 0) + if (strcmp (s->opcode, "jumpb") == 0) flow_add_op_var (use, s->opb, 1); } if (operands) { diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index 9ac87ea10..d0f11684b 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -53,26 +53,26 @@ typedef struct v6p_uint_opcode_s { } v6p_uint_opcode_t; static v6p_uint_opcode_t v6p_uint_opcodes[] = { - {OP_LOAD_I_v6p, {".", "load.i", ev_entity, ev_field, ev_uint }}, - {OP_LOADBI_I_v6p, {".", "loadbi.i", ev_ptr, ev_short, ev_uint }}, - {OP_ADDRESS_I_v6p, {"&", "address.i", ev_uint, ev_invalid, ev_ptr }}, - {OP_STORE_I_v6p, {"=", "store.i", ev_uint, ev_uint, ev_invalid }}, - {OP_STOREP_I_v6p, {".=", "storep.i", ev_uint, ev_ptr, ev_invalid }}, - {OP_STOREB_I_v6p, {".=", "storeb.i", ev_uint, ev_ptr, ev_int }}, - {OP_STOREBI_I_v6p, {".=", "storebi.i", ev_uint, ev_ptr, ev_short }}, - {OP_IF_v6p, {"", "if", ev_uint, ev_short, ev_invalid }}, - {OP_IFNOT_v6p, {"", "ifnot", ev_uint, ev_short, ev_invalid }}, - {OP_ADD_I_v6p, {"+", "add.i", ev_uint, ev_uint, ev_uint }}, - {OP_SUB_I_v6p, {"-", "sub.i", ev_uint, ev_uint, ev_uint }}, - {OP_MUL_I_v6p, {"*", "mul.i", ev_uint, ev_uint, ev_uint }}, - {OP_DIV_I_v6p, {"/", "div.i", ev_uint, ev_uint, ev_uint }}, - {OP_BITAND_I_v6p, {"&", "bitand.i", ev_uint, ev_uint, ev_uint }}, - {OP_BITOR_I_v6p, {"|", "bitor.i", ev_uint, ev_uint, ev_uint }}, - {OP_BITXOR_I_v6p, {"^", "bitxor.i", ev_uint, ev_uint, ev_uint }}, - {OP_REM_I_v6p, {"%", "rem.i", ev_uint, ev_uint, ev_uint }}, - {OP_MOD_I_v6p, {"%%", "mod.i", ev_uint, ev_uint, ev_uint }}, - {OP_SHL_I_v6p, {"<<", "shl.i", ev_uint, ev_uint, ev_uint }}, - {OP_BITNOT_I_v6p, {"<<", "bitnot.i", ev_uint, ev_invalid, ev_int }}, + {OP_LOAD_I_v6p, {"load", "load.i", ev_entity, ev_field, ev_uint }}, + {OP_LOADBI_I_v6p, {"load", "loadbi.i", ev_ptr, ev_short, ev_uint }}, + {OP_ADDRESS_I_v6p, {"lea", "address.i",ev_uint, ev_invalid, ev_ptr }}, + {OP_STORE_I_v6p, {"assign", "store.i", ev_uint, ev_uint, ev_invalid }}, + {OP_STOREP_I_v6p, {"store", "storep.i", ev_uint, ev_ptr, ev_invalid }}, + {OP_STOREB_I_v6p, {"store", "storeb.i", ev_uint, ev_ptr, ev_int }}, + {OP_STOREBI_I_v6p, {"store", "storebi.i",ev_uint, ev_ptr, ev_short }}, + {OP_IF_v6p, {"if", "if", ev_uint, ev_short, ev_invalid }}, + {OP_IFNOT_v6p, {"ifnot", "ifnot", ev_uint, ev_short, ev_invalid }}, + {OP_ADD_I_v6p, {"add", "add.i", ev_uint, ev_uint, ev_uint }}, + {OP_SUB_I_v6p, {"sub", "sub.i", ev_uint, ev_uint, ev_uint }}, + {OP_MUL_I_v6p, {"mul", "mul.i", ev_uint, ev_uint, ev_uint }}, + {OP_DIV_I_v6p, {"div", "div.i", ev_uint, ev_uint, ev_uint }}, + {OP_BITAND_I_v6p, {"bitand", "bitand.i", ev_uint, ev_uint, ev_uint }}, + {OP_BITOR_I_v6p, {"bitor", "bitor.i", ev_uint, ev_uint, ev_uint }}, + {OP_BITXOR_I_v6p, {"bitxor", "bitxor.i", ev_uint, ev_uint, ev_uint }}, + {OP_REM_I_v6p, {"rem", "rem.i", ev_uint, ev_uint, ev_uint }}, + {OP_MOD_I_v6p, {"mod", "mod.i", ev_uint, ev_uint, ev_uint }}, + {OP_SHL_I_v6p, {"shl", "shl.i", ev_uint, ev_uint, ev_uint }}, + {OP_BITNOT_I_v6p, {"bitnot", "bitnot.i", ev_uint, ev_invalid, ev_int }}, {} }; diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index d5b385f14..bc7013f91 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -571,28 +571,28 @@ static const char * convert_op (int op) { switch (op) { - case OR: return "||"; - case AND: return "&&"; - case EQ: return "=="; - case NE: return "!="; - case LE: return "<="; - case GE: return ">="; - case LT: return "<"; - case GT: return ">"; - case '+': return "+"; - case '-': return "-"; - case '*': return "*"; - case '/': return "/"; - case '%': return "%"; - case MOD: return "%%"; - case '&': return "&"; - case '|': return "|"; - case '^': return "^"; - case '~': return "~"; - case '!': return "!"; - case SHL: return "<<"; - case SHR: return ">>"; - case '.': return "."; + case OR: return "or"; + case AND: return "and"; + case EQ: return "eq"; + case NE: return "ne"; + case LE: return "le"; + case GE: return "ge"; + case LT: return "lt"; + case GT: return "gt"; + case '+': return "add"; + case '-': return "sub"; + case '*': return "mul"; + case '/': return "div"; + case '%': return "rem"; + case MOD: return "mod"; + case '&': return "bitand"; + case '|': return "bitor"; + case '^': return "bitxor"; + case '~': return "bitnot"; + case '!': return "not"; + case SHL: return "shl"; + case SHR: return "shr"; + case '.': return "load"; default: return 0; } @@ -603,7 +603,7 @@ statement_is_cond (statement_t *s) { if (!s) return 0; - return !strncmp (s->opcode, "opcode, "if", 2); } int @@ -611,7 +611,7 @@ statement_is_goto (statement_t *s) { if (!s) return 0; - return !strcmp (s->opcode, ""); + return !strcmp (s->opcode, "jump"); } int @@ -619,7 +619,7 @@ statement_is_jumpb (statement_t *s) { if (!s) return 0; - return !strcmp (s->opcode, ""); + return !strcmp (s->opcode, "jumpb"); } int @@ -627,9 +627,9 @@ statement_is_call (statement_t *s) { if (!s) return 0; - if (!strncmp (s->opcode, "opcode, "call", 4)) return 1; - if (!strncmp (s->opcode, "opcode, "rcall", 5)) return 2; return 0; } @@ -639,7 +639,7 @@ statement_is_return (statement_t *s) { if (!s) return 0; - return !strncmp (s->opcode, "opcode, "return", 6); } sblock_t * @@ -687,18 +687,18 @@ statement_get_targetlist (statement_t *s) static void invert_conditional (statement_t *s) { - if (!strcmp (s->opcode, "")) - s->opcode = ""; - else if (!strcmp (s->opcode, "")) - s->opcode = ""; - else if (!strcmp (s->opcode, "")) - s->opcode = ""; - else if (!strcmp (s->opcode, "")) - s->opcode = ""; - else if (!strcmp (s->opcode, "")) - s->opcode = ""; - else if (!strcmp (s->opcode, "")) - s->opcode = ""; + if (!strcmp (s->opcode, "if")) + s->opcode = "ifnot"; + else if (!strcmp (s->opcode, "ifnot")) + s->opcode = "if"; + else if (!strcmp (s->opcode, "ifbe")) + s->opcode = "ifa"; + else if (!strcmp (s->opcode, "ifb")) + s->opcode = "ifae"; + else if (!strcmp (s->opcode, "ifae")) + s->opcode = "ifb"; + else if (!strcmp (s->opcode, "ifa")) + s->opcode = "ifbe"; } typedef sblock_t *(*statement_f) (sblock_t *, expr_t *); @@ -712,7 +712,7 @@ static sblock_t * expr_address (sblock_t *sblock, expr_t *e, operand_t **op) { statement_t *s; - s = new_statement (st_expr, "&", e); + s = new_statement (st_expr, "lea", e); sblock = statement_subexpr (sblock, e->e.address.lvalue, &s->opa); if (e->e.address.offset) { sblock = statement_subexpr (sblock, e->e.address.offset, &s->opb); @@ -797,8 +797,8 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) operand_t *dst = 0; operand_t *size = 0; static const char *opcode_sets[][2] = { - {"", ""}, - {"", ""}, + {"move", "movep"}, + {"memset", "memsetp"}, }; const unsigned max_count = 1 << 16; const char **opcode_set = opcode_sets[0]; @@ -887,7 +887,7 @@ expr_assign (sblock_t *sblock, expr_t *e, operand_t **op) operand_t *src = 0; operand_t *dst = 0; operand_t *ofs = 0; - const char *opcode = "="; + const char *opcode = "assign"; st_type_t type; if (src_expr->type == ex_assign) { @@ -931,7 +931,7 @@ dereference_dst: // dst_expr is a dereferenced pointer, so need to un-dereference it // to get the pointer and switch to storep instructions. dst_expr = expr_file_line (address_expr (dst_expr, 0, 0), e); - opcode = ".="; // FIXME find a nicer representation (lose strings?) + opcode = "store";// FIXME find a nicer representation (lose strings?) if (dst_expr->type == ex_address && dst_expr->e.address.offset && !is_const_ptr (dst_expr->e.address.lvalue)) { sblock = statement_subexpr (sblock, @@ -952,7 +952,7 @@ dereference_dst: } if (is_entity (dst->type) && ofs && is_field (ofs->type)) { - s = new_statement (st_expr, "&", dst_expr); + s = new_statement (st_expr, "lea", dst_expr); s->opa = dst; s->opb = ofs; s->opc = temp_operand (&type_ptr, dst_expr); @@ -1012,7 +1012,7 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) ind--; param = new_param_expr (get_type (a), ind); if (count && options.code.progsversion != PROG_ID_VERSION && ind < 2) { - pref = "R"; + pref = "r"; sblock = statement_subexpr (sblock, param, &arguments[ind]); if (options.code.vector_calls && a->type == ex_value && a->e.value->lltype == ev_vector) @@ -1037,7 +1037,7 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) arg = p; sblock = statement_subexpr (sblock, a, &arg); if (arg != p) { - s = new_statement (st_assign, "=", a); + s = new_statement (st_assign, "assign", a); s->opa = arg; s->opb = p; sblock_add_statement (sblock, s); @@ -1045,7 +1045,7 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) } } } - opcode = va (0, "<%sCALL%d>", pref, count); + opcode = va (0, "%scall%d", pref, count); s = new_statement (st_func, opcode, call); sblock = statement_subexpr (sblock, func, &s->opa); s->opb = arguments[0]; @@ -1059,13 +1059,13 @@ static sblock_t * statement_branch (sblock_t *sblock, expr_t *e) { static const char *opcodes[] = { - "", - "", - "", + "ifnot", + "ifb", + "ifa", 0, // special handling - "", - "", - "", + "if", + "ifae", + "ifbe", 0, // not used here }; statement_t *s = 0; @@ -1076,11 +1076,11 @@ statement_branch (sblock_t *sblock, expr_t *e) } if (e->e.branch.type == pr_branch_jump) { if (e->e.branch.index) { - s = new_statement (st_flow, "", e); + s = new_statement (st_flow, "jumpb", e); sblock = statement_subexpr (sblock, e->e.branch.target, &s->opa); sblock = statement_subexpr (sblock, e->e.branch.index, &s->opb); } else { - s = new_statement (st_flow, "", e); + s = new_statement (st_flow, "jump", e); s->opa = label_operand (e->e.branch.target); } } else { @@ -1102,10 +1102,10 @@ statement_return (sblock_t *sblock, expr_t *e) statement_t *s; debug (e, "RETURN"); - opcode = ""; + opcode = "return"; if (!e->e.retrn.ret_val) { if (options.code.progsversion != PROG_ID_VERSION) { - opcode = ""; + opcode = "return_v"; } else { e->e.retrn.ret_val = new_float_expr (0); } @@ -1125,7 +1125,7 @@ statement_return (sblock_t *sblock, expr_t *e) static statement_t * lea_statement (operand_t *pointer, operand_t *offset, expr_t *e) { - statement_t *s = new_statement (st_expr, "&", e); + statement_t *s = new_statement (st_expr, "lea", e); s->opa = pointer; s->opb = offset; s->opc = temp_operand (&type_ptr, e); @@ -1162,14 +1162,14 @@ expr_deref (sblock_t *sblock, expr_t *deref, operand_t **op) dst_addr = operand_address (*op, e); - s = new_statement (st_ptrmove, "", deref); + s = new_statement (st_ptrmove, "movep", deref); s->opa = src_addr; //FIXME large types s->opb = short_operand (type_size (type), e); s->opc = dst_addr; sblock_add_statement (sblock, s); } else { - s = new_statement (st_expr, ".", deref); + s = new_statement (st_expr, "load", deref); s->opa = ptr; s->opb = offs; s->opc = *op; @@ -1186,7 +1186,7 @@ expr_deref (sblock_t *sblock, expr_t *deref, operand_t **op) sblock = statement_subexpr (sblock, e, &ptr); if (!*op) *op = temp_operand (type, e); - s = new_statement (st_expr, ".", deref); + s = new_statement (st_expr, "load", deref); s->opa = ptr; s->opb = short_operand (0, e); s->opc = *op; @@ -1295,7 +1295,7 @@ expr_cast (sblock_t *sblock, expr_t *e, operand_t **op) operand_t *src = 0; sblock = statement_subexpr (sblock, e->e.expr.e1, &src); *op = temp_operand (e->e.expr.type, e); - s = new_statement (st_expr, "", e); + s = new_statement (st_expr, "conv", e); s->opa = src; s->opc = *op; sblock_add_statement (sblock, s); @@ -1483,7 +1483,7 @@ expr_nil (sblock_t *sblock, expr_t *e, operand_t **op) sblock = statement_subexpr (sblock, new_int_expr(0), &zero); sblock = statement_subexpr (sblock, size_expr, &size); - s = new_statement (st_memset, "", e); + s = new_statement (st_memset, "memset", e); s->opa = zero; s->opb = size; s->opc = *op; @@ -1549,7 +1549,7 @@ statement_state (sblock_t *sblock, expr_t *e) { statement_t *s; - s = new_statement (st_state, "", e); + s = new_statement (st_state, "state", e); sblock = statement_subexpr (sblock, e->e.state.frame, &s->opa); sblock = statement_subexpr (sblock, e->e.state.think, &s->opb); sblock = statement_subexpr (sblock, e->e.state.step, &s->opc); @@ -1738,7 +1738,7 @@ statement_memset (sblock_t *sblock, expr_t *e) expr_t *dst = e->e.memset.dst; expr_t *val = e->e.memset.val; expr_t *count = e->e.memset.count; - const char *opcode = ""; + const char *opcode = "memset"; statement_t *s; if (is_constant (count)) { @@ -2115,9 +2115,9 @@ check_final_block (sblock_t *sblock) sblock->next = new_sblock (); sblock = sblock->next; } - s = new_statement (st_func, "", 0); + s = new_statement (st_func, "return_v", 0); if (options.traditional || options.code.progsversion == PROG_ID_VERSION) { - s->opcode = save_string (""); + s->opcode = save_string ("return"); s->opa = return_operand (&type_void, 0); } sblock_add_statement (sblock, s); From a4ebd6aa58ed28584631ee7ba3da00d6d92693e1 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 12:41:01 +0900 Subject: [PATCH 161/360] [gamecode] Fix a few missed opcode renames if and ifnot became ifnz and ifz, and return_v lost its tail (it was always redundant, except in dags, and that's fixed with a pointer check). --- libs/gamecode/pr_v6p_opcode.c | 6 +++--- tools/qfcc/source/dags.c | 2 +- tools/qfcc/source/opcodes.c | 4 ++-- tools/qfcc/source/statements.c | 21 +++++++++------------ 4 files changed, 15 insertions(+), 18 deletions(-) diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index 20f717154..e9b3a0b7a 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -756,7 +756,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ra", }, - [OP_RETURN_V_v6p] = {"return_v", "return", + [OP_RETURN_V_v6p] = {"return", "return", ev_invalid, ev_invalid, ev_invalid, PROG_V6P_VERSION, "", @@ -803,12 +803,12 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { "%Ga, %gc", }, - [OP_IF_v6p] = {"if", "if", + [OP_IF_v6p] = {"ifnz", "if", ev_int, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", }, - [OP_IFNOT_v6p] = {"ifnot", "ifnot", + [OP_IFNOT_v6p] = {"ifz", "ifnot", ev_int, ev_short, ev_invalid, PROG_ID_VERSION, "%Ga branch %sb (%Ob)", diff --git a/tools/qfcc/source/dags.c b/tools/qfcc/source/dags.c index 3040c5425..bdfd4ab7d 100644 --- a/tools/qfcc/source/dags.c +++ b/tools/qfcc/source/dags.c @@ -457,7 +457,7 @@ dagnode_set_edges (dag_t *dag, dagnode_t *n) first_param = 2; } else if (!strncmp (n->label->opcode, "call", 4)) { num_params = n->label->opcode + 5; - } else if (!strcmp (n->label->opcode, "return")) { + } else if (!strcmp (n->label->opcode, "return") && n->children[0]) { daglabel_t *label = n->children[0]->label; if (!label->op) { set_iter_t *lab_i; diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index d0f11684b..f0cc4e358 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -60,8 +60,8 @@ static v6p_uint_opcode_t v6p_uint_opcodes[] = { {OP_STOREP_I_v6p, {"store", "storep.i", ev_uint, ev_ptr, ev_invalid }}, {OP_STOREB_I_v6p, {"store", "storeb.i", ev_uint, ev_ptr, ev_int }}, {OP_STOREBI_I_v6p, {"store", "storebi.i",ev_uint, ev_ptr, ev_short }}, - {OP_IF_v6p, {"if", "if", ev_uint, ev_short, ev_invalid }}, - {OP_IFNOT_v6p, {"ifnot", "ifnot", ev_uint, ev_short, ev_invalid }}, + {OP_IF_v6p, {"ifnz", "if", ev_uint, ev_short, ev_invalid }}, + {OP_IFNOT_v6p, {"ifz", "ifnot", ev_uint, ev_short, ev_invalid }}, {OP_ADD_I_v6p, {"add", "add.i", ev_uint, ev_uint, ev_uint }}, {OP_SUB_I_v6p, {"sub", "sub.i", ev_uint, ev_uint, ev_uint }}, {OP_MUL_I_v6p, {"mul", "mul.i", ev_uint, ev_uint, ev_uint }}, diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index bc7013f91..48257be54 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -687,10 +687,10 @@ statement_get_targetlist (statement_t *s) static void invert_conditional (statement_t *s) { - if (!strcmp (s->opcode, "if")) - s->opcode = "ifnot"; - else if (!strcmp (s->opcode, "ifnot")) - s->opcode = "if"; + if (!strcmp (s->opcode, "ifnz")) + s->opcode = "ifz"; + else if (!strcmp (s->opcode, "ifz")) + s->opcode = "ifnz"; else if (!strcmp (s->opcode, "ifbe")) s->opcode = "ifa"; else if (!strcmp (s->opcode, "ifb")) @@ -931,7 +931,7 @@ dereference_dst: // dst_expr is a dereferenced pointer, so need to un-dereference it // to get the pointer and switch to storep instructions. dst_expr = expr_file_line (address_expr (dst_expr, 0, 0), e); - opcode = "store";// FIXME find a nicer representation (lose strings?) + opcode = "store"; if (dst_expr->type == ex_address && dst_expr->e.address.offset && !is_const_ptr (dst_expr->e.address.lvalue)) { sblock = statement_subexpr (sblock, @@ -1059,11 +1059,11 @@ static sblock_t * statement_branch (sblock_t *sblock, expr_t *e) { static const char *opcodes[] = { - "ifnot", + "ifz", "ifb", "ifa", 0, // special handling - "if", + "ifnz", "ifae", "ifbe", 0, // not used here @@ -1104,9 +1104,7 @@ statement_return (sblock_t *sblock, expr_t *e) debug (e, "RETURN"); opcode = "return"; if (!e->e.retrn.ret_val) { - if (options.code.progsversion != PROG_ID_VERSION) { - opcode = "return_v"; - } else { + if (options.code.progsversion == PROG_ID_VERSION) { e->e.retrn.ret_val = new_float_expr (0); } } @@ -2115,9 +2113,8 @@ check_final_block (sblock_t *sblock) sblock->next = new_sblock (); sblock = sblock->next; } - s = new_statement (st_func, "return_v", 0); + s = new_statement (st_func, "return", 0); if (options.traditional || options.code.progsversion == PROG_ID_VERSION) { - s->opcode = save_string ("return"); s->opa = return_operand (&type_void, 0); } sblock_add_statement (sblock, s); From 19baae6969eb1990bb899a34eada2c303bcdfe4e Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 12:55:56 +0900 Subject: [PATCH 162/360] [qfcc] Dump emitted statements when verbosity >= 2 I wish I had done this years (decades, even!) ago. It makes checking the output so much easier. --- tools/qfcc/include/opcodes.h | 1 + tools/qfcc/source/emit.c | 4 ++++ tools/qfcc/source/opcodes.c | 12 ++++++++++++ 3 files changed, 17 insertions(+) diff --git a/tools/qfcc/include/opcodes.h b/tools/qfcc/include/opcodes.h index fa100fb6b..055066f4b 100644 --- a/tools/qfcc/include/opcodes.h +++ b/tools/qfcc/include/opcodes.h @@ -40,5 +40,6 @@ pr_ushort_t opcode_get (instruction_t *inst) __attribute__((pure)); instruction_t *opcode_find (const char *name, struct operand_s *op_a, struct operand_s *op_b, struct operand_s *op_c); void opcode_init (void); +void opcode_print_statement (pr_uint_t addr, dstatement_t *st); #endif//__opcodes_h diff --git a/tools/qfcc/source/emit.c b/tools/qfcc/source/emit.c index dc5bb4b2d..ceb67622a 100644 --- a/tools/qfcc/source/emit.c +++ b/tools/qfcc/source/emit.c @@ -217,6 +217,10 @@ emit_statement (statement_t *statement) s->b = def_b ? def_b->offset : 0; s->c = def_c ? def_c->offset : 0; + if (options.verbosity >= 2) { + opcode_print_statement (pr.code->size - 1, s); + } + add_statement_def_ref (def_a, s, 0); add_statement_def_ref (def_b, s, 1); add_statement_def_ref (def_c, s, 2); diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index f0cc4e358..3815c54e1 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -351,3 +351,15 @@ opcode_init (void) rua_opcode_init (); } } + +void +opcode_print_statement (pr_uint_t addr, dstatement_t *st) +{ + const char *mnemonic; + if (options.code.progsversion < PROG_VERSION) { + mnemonic = v6p_opcode_map[st->op].opname; + } else { + mnemonic = pr_opcodes[st->op].mnemonic; + } + printf ("%04x %8s %04x %04x %04x\n", addr, mnemonic, st->a, st->b, st->c); +} From 875d4dc7cf8bde96a72a7ad3c4cf30c3c803d1a8 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 13:02:12 +0900 Subject: [PATCH 163/360] [gamecode] Correct some ruamoko instruction meta data There were some errors in instruction names and operand types resulting in unsearchable instructions. --- libs/gamecode/opcodes.py | 27 ++++++++++++++++++++------- 1 file changed, 20 insertions(+), 7 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index f35067a7e..6ff35e892 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -93,7 +93,7 @@ branch_formats = { "opname": "{op_cond[c*4+cc]}", "format": "{cond_fmt[c*4+cc]}{branch_fmt[0]}", "widths": "{cond_widths[c*4+cc]}", - "types": "ev_void, ev_void, ev_int", + "types": "ev_short, ev_invalid, ev_int", "args": { "op_mode": "ABCD", "op_cond": ["ifz", "ifb", "ifa", None, @@ -173,12 +173,18 @@ jump_formats = { "opcode": "OP_JUMP_{op_mode[mm]}", "mnemonic": "jump", "opname": "jump", - "format": "{branch_fmt[mm]}", + "format": "{jump_fmt[mm]}", "widths": "0, 0, 0", - "types": "ev_void, ev_void, ev_invalid", + "types": "{jump_types[mm]}", "args": { "op_mode": "ABCD", - "branch_fmt": branch_fmt, + "jump_fmt": branch_fmt, + "jump_types": [ + "ev_short, ev_invalid, ev_invalid", + "ev_ptr, ev_invalid, ev_invalid", + "ev_ptr, ev_short, ev_invalid", + "ev_ptr, ev_int, ev_invalid", + ], }, } lea_formats = { @@ -358,11 +364,11 @@ stated_formats = { } store_formats = { "opcode": "OP_STORE_{op_mode[mm]}_{ss+1}", - "mnemonic": "store", - "opname": "store", + "mnemonic": "{store_op[mm]}", + "opname": "{store_op[mm]}", "format": "{store_fmt[mm]}", "widths": "{ss+1}, 0, {ss+1}", - "types": "ev_void, ev_void, ev_void", + "types": "{store_types[mm]}", "args": { "op_mode": "ABCD", "store_fmt": [ @@ -371,6 +377,13 @@ store_formats = { "%Gc, *(%Ga + %sb)", "%Gc, *(%Ga + %Gb)", ], + "store_op": ["assign", "store", "store", "store"], + "store_types": [ + "ev_void, ev_invalid, ev_void", + "ev_ptr, ev_invalid, ev_void", + "ev_ptr, ev_short, ev_void", + "ev_ptr, ev_int, ev_void", + ], }, } string_formats = { From a5a80172202a133c4df4bb06bac62e2d59c5a5eb Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 13:05:08 +0900 Subject: [PATCH 164/360] [qfcc] Switch internal statement format to ruamoko For the most part, it wasn't too bad as it's just a rotation of the operands for some instructions (store, assign, branch), but dealing with all the direct accesses to specific operands was a small pain. I am very glad I made all those automated tests :) --- tools/qfcc/source/dags.c | 18 ++++++------ tools/qfcc/source/emit.c | 30 +++++++++++++++----- tools/qfcc/source/flow.c | 48 ++++++++++++++++++++----------- tools/qfcc/source/statements.c | 52 ++++++++++++++++++++-------------- 4 files changed, 94 insertions(+), 54 deletions(-) diff --git a/tools/qfcc/source/dags.c b/tools/qfcc/source/dags.c index bdfd4ab7d..5b3a64b3d 100644 --- a/tools/qfcc/source/dags.c +++ b/tools/qfcc/source/dags.c @@ -1116,12 +1116,12 @@ generate_assignments (dag_t *dag, sblock_t *block, operand_t *src, operand_t *operands[3] = {0, 0, 0}; daglabel_t *var; - operands[0] = fix_op_type (src, type); + operands[2] = fix_op_type (src, type); for ( ; var_iter; var_iter = set_next (var_iter)) { var = dag->labels[var_iter->element]; - operands[1] = fix_op_type (var->op, type); + operands[0] = fix_op_type (var->op, type); if (!dst) - dst = operands[1]; + dst = operands[0]; st = build_statement ("assign", operands, var->expr); sblock_add_statement (block, st); @@ -1172,15 +1172,15 @@ dag_gencode (dag_t *dag, sblock_t *block, dagnode_t *dagnode) case st_assign: internal_error (0, "unexpected assignment node"); case st_ptrassign: - operands[0] = make_operand (dag, block, dagnode, 0); - operands[1] = make_operand (dag, block, dagnode, 1); - if (dagnode->children[2]) - operands[2] = make_operand (dag, block, dagnode, 2); + operands[2] = make_operand (dag, block, dagnode, 0); + operands[0] = make_operand (dag, block, dagnode, 2); + if (dagnode->children[1]) + operands[1] = make_operand (dag, block, dagnode, 1); st = build_statement (dagnode->label->opcode, operands, dagnode->label->expr); sblock_add_statement (block, st); // the source location is suitable for use in other nodes - dst = operands[0]; + dst = operands[2]; break; case st_move: dst = generate_moves (dag, block, dagnode); @@ -1207,6 +1207,8 @@ dag_gencode (dag_t *dag, sblock_t *block, dagnode_t *dagnode) operands[0] = make_operand (dag, block, dagnode, 0); if (dagnode->children[1]) operands[1] = make_operand (dag, block, dagnode, 1); + if (dagnode->children[2]) + operands[2] = make_operand (dag, block, dagnode, 2); st = build_statement (dagnode->label->opcode, operands, dagnode->label->expr); sblock_add_statement (block, st); diff --git a/tools/qfcc/source/emit.c b/tools/qfcc/source/emit.c index ceb67622a..3ee80df7f 100644 --- a/tools/qfcc/source/emit.c +++ b/tools/qfcc/source/emit.c @@ -183,20 +183,36 @@ static void emit_statement (statement_t *statement) { const char *opcode = statement->opcode; + operand_t *op_a, *op_b, *op_c; def_t *def_a, *def_b, *def_c; instruction_t *inst; dstatement_t *s; - def_a = get_operand_def (statement->expr, statement->opa); + if (options.code.progsversion < PROG_VERSION + && (strcmp (statement->opcode, "store") == 0 + || strcmp (statement->opcode, "assign") == 0 + || statement_is_cond (statement))) { + // the operands for assign, store and branch instructions are rotated + // when comparing v6/v6p and ruamoko + op_a = statement->opc; + op_b = statement->opa; + op_c = statement->opb; + } else { + op_a = statement->opa; + op_b = statement->opb; + op_c = statement->opc; + } + def_a = get_operand_def (statement->expr, op_a); use_tempop (statement->opa, statement->expr); - def_b = get_operand_def (statement->expr, statement->opb); + def_b = get_operand_def (statement->expr, op_b); use_tempop (statement->opb, statement->expr); - def_c = get_operand_def (statement->expr, statement->opc); + def_c = get_operand_def (statement->expr, op_c); use_tempop (statement->opc, statement->expr); - inst = opcode_find (opcode, statement->opa, statement->opb, statement->opc); + inst = opcode_find (opcode, op_a, op_b, op_c); if (!inst) { print_expr (statement->expr); + printf ("%d ", pr.code->size); print_statement (statement); internal_error (statement->expr, "ice ice baby"); } @@ -225,9 +241,9 @@ emit_statement (statement_t *statement) add_statement_def_ref (def_b, s, 1); add_statement_def_ref (def_c, s, 2); - add_statement_op_ref (statement->opa, s, 0); - add_statement_op_ref (statement->opb, s, 1); - add_statement_op_ref (statement->opc, s, 2); + add_statement_op_ref (op_a, s, 0); + add_statement_op_ref (op_b, s, 1); + add_statement_op_ref (op_c, s, 2); } void diff --git a/tools/qfcc/source/flow.c b/tools/qfcc/source/flow.c index d713b1ce8..5ed2022da 100644 --- a/tools/qfcc/source/flow.c +++ b/tools/qfcc/source/flow.c @@ -1149,9 +1149,11 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, operand_t *operands[FLOW_OPERANDS]) { int i, start, calln = -1; + operand_t *src_op = 0; operand_t *res_op = 0; operand_t *aux_op1 = 0; operand_t *aux_op2 = 0; + operand_t *aux_op3 = 0; if (use) { set_empty (use); @@ -1191,11 +1193,11 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, } break; case st_assign: - flow_add_op_var (def, s->opb, 0); - flow_add_op_var (use, s->opa, 1); + flow_add_op_var (def, s->opa, 0); + flow_add_op_var (use, s->opc, 1); if (operands) { - operands[0] = s->opb; - operands[1] = s->opa; + operands[0] = s->opa; + operands[1] = s->opc; } break; case st_ptrassign: @@ -1205,23 +1207,28 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, case st_ptrmemset: flow_add_op_var (use, s->opa, 1); flow_add_op_var (use, s->opb, 1); + aux_op1 = s->opb; if (!strcmp (s->opcode, "move") || !strcmp (s->opcode, "memset")) { flow_add_op_var (def, s->opc, 0); + src_op = s->opa; res_op = s->opc; } else if (!strcmp (s->opcode, "movep")) { flow_add_op_var (use, s->opc, 0); - aux_op2 = flow_analyze_pointer_operand (s->opa, use); + aux_op3 = flow_analyze_pointer_operand (s->opa, use); res_op = flow_analyze_pointer_operand (s->opc, def); - aux_op1 = s->opc; + src_op = s->opa; + aux_op2 = s->opc; } else if (!strcmp (s->opcode, "memsetp")) { flow_add_op_var (use, s->opc, 0); res_op = flow_analyze_pointer_operand (s->opc, def); - aux_op1 = s->opc; + src_op = s->opa; + aux_op2 = s->opc; } else if (!strcmp (s->opcode, "store")) { - flow_add_op_var (use, s->opc, 1); - res_op = flow_analyze_pointer_operand (s->opb, def); - aux_op1 = s->opc; + flow_add_op_var (use, s->opb, 1); + res_op = flow_analyze_pointer_operand (s->opa, def); + src_op = s->opc; + aux_op2 = s->opa; } else { internal_error (s->expr, "unexpected opcode '%s' for %d", s->opcode, s->type); @@ -1231,10 +1238,10 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, } if (operands) { operands[0] = res_op; - operands[1] = s->opa; - operands[2] = s->opb; - operands[3] = aux_op1; - operands[4] = aux_op2; + operands[1] = src_op; + operands[2] = aux_op1; + operands[3] = aux_op2; + operands[4] = aux_op3; } break; case st_state: @@ -1296,14 +1303,21 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, } break; case st_flow: - if (strcmp (s->opcode, "jump") != 0) { + if (statement_is_goto (s)) { + // opa is just a label + } else if (statement_is_jumpb (s)) { flow_add_op_var (use, s->opa, 1); - if (strcmp (s->opcode, "jumpb") == 0) - flow_add_op_var (use, s->opb, 1); + flow_add_op_var (use, s->opb, 1); + } else if (statement_is_cond (s)) { + flow_add_op_var (use, s->opc, 1); + } else { + internal_error (s->expr, "unexpected flow statement: %s", + s->opcode); } if (operands) { operands[1] = s->opa; operands[2] = s->opb; + operands[3] = s->opc; } break; } diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 48257be54..cd9245a93 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -642,14 +642,22 @@ statement_is_return (statement_t *s) return !strncmp (s->opcode, "return", 6); } +static ex_label_t ** +statement_get_labelref (statement_t *s) +{ + if (statement_is_cond (s) + || statement_is_goto (s) + || statement_is_jumpb (s)) { + return &s->opa->label; + } + return 0; +} + sblock_t * statement_get_target (statement_t *s) { - if (statement_is_cond (s)) - return s->opb->label->dest; - if (statement_is_goto (s)) - return s->opa->label->dest; - return 0; + ex_label_t **label = statement_get_labelref (s); + return label ? (*label)->dest : 0; } sblock_t ** @@ -961,9 +969,9 @@ dereference_dst: ofs = 0; } s = new_statement (type, opcode, e); - s->opa = src; - s->opb = dst; - s->opc = ofs; + s->opa = dst; + s->opb = ofs; + s->opc = src; sblock_add_statement (sblock, s); return sblock; } @@ -1038,8 +1046,8 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) sblock = statement_subexpr (sblock, a, &arg); if (arg != p) { s = new_statement (st_assign, "assign", a); - s->opa = arg; - s->opb = p; + s->opa = p; + s->opc = arg; sblock_add_statement (sblock, s); } } @@ -1086,8 +1094,8 @@ statement_branch (sblock_t *sblock, expr_t *e) } else { opcode = opcodes [e->e.branch.type]; s = new_statement (st_flow, opcode, e); - sblock = statement_subexpr (sblock, e->e.branch.test, &s->opa); - s->opb = label_operand (e->e.branch.target); + sblock = statement_subexpr (sblock, e->e.branch.test, &s->opc); + s->opa = label_operand (e->e.branch.target); } sblock_add_statement (sblock, s); @@ -1928,14 +1936,15 @@ thread_jumps (sblock_t *blocks) (*label)->symbol = 0; } } else if (statement_is_cond (s)) { - label = &s->opb->label; + label = &s->opa->label; } else { continue; } for (l = *label; l->dest && l->dest->statements && statement_is_goto (l->dest->statements); - l = l->dest->statements->opa->label) { + l = *statement_get_labelref (l->dest->statements)) { + // empty loop } if (l != *label) { unuse_label (*label); @@ -1988,11 +1997,12 @@ remove_dead_blocks (sblock_t *blocks) s = (statement_t *) sblock->tail; if (statement_is_cond (s) && sb->statements && statement_is_goto (sb->statements) - && s->opb->label->dest == sb->next) { + && statement_get_target (s) == sb->next) { debug (0, "merging if/goto %p %p", sblock, sb); - unuse_label (s->opb->label); - s->opb->label = sb->statements->opa->label; - s->opb->label->used++; + ex_label_t **labelref = statement_get_labelref(s); + unuse_label (*labelref); + *labelref = *statement_get_labelref (sb->statements); + (*labelref)->used++; invert_conditional (s); sb->reachable = 0; for (sb = sb->next; sb; sb = sb->next) @@ -2014,10 +2024,8 @@ remove_dead_blocks (sblock_t *blocks) if (sb->statements) { s = (statement_t *) sb->tail; - if (statement_is_goto (s)) - label = s->opa->label; - else if (statement_is_cond (s)) - label = s->opb->label; + ex_label_t **labelref = statement_get_labelref (s); + label = labelref ? *labelref : 0; } unuse_label (label); did_something = 1; From 6ae9daf4b7cf89c3a8e22368ac098e1132a37de5 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 14:52:59 +0900 Subject: [PATCH 165/360] [gamecode] Clean out dead any/all/none data The instructions are gone as hor/hand/hnor take care of them. --- libs/gamecode/opcodes.py | 27 --------------------------- 1 file changed, 27 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 6ff35e892..c8316eb16 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -52,22 +52,6 @@ etype_tt = ["ev_int", "ev_float", "ev_long", "ev_double"] unsigned_t = ["ev_uint", "ev_ulong"] float_t = ["ev_float", "ev_double"] -all_formats = { - "opcode": "OP_ALL_{ss+1}", - "mnemonic": "all", - "opname": "all", - "format": "%Ga, %gc", - "widths": "{ss+1}, 0, 1", - "types": "ev_int, ev_int, ev_int", -} -any_formats = { - "opcode": "OP_ANY_{ss+1}", - "mnemonic": "any", - "opname": "any", - "format": "%Ga, %gc", - "widths": "{ss+1}, 0, 1", - "types": "ev_int, ev_int, ev_int", -} bitops_formats = { "opcode": "OP_{op_bit[oo].upper()}_{bit_type[t]}_{ss+1}", "mnemonic": "{op_bit[oo]}", @@ -252,14 +236,6 @@ move_formats = { "move_fmt": ["%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc", None], }, } -none_formats = { - "opcode": "OP_NONE_{ss+1}", - "mnemonic": "none", - "opname": "none", - "format": "%Ga, %gc", - "widths": "{ss+1}, 0, 1", - "types": "ev_int, ev_invalid, ev_int", -} push_formats = { "opcode": "OP_PUSH_{op_mode[mm]}_{ss+1}", "mnemonic": "push", @@ -482,8 +458,6 @@ with_formats = { } group_map = { - "all": all_formats, - "any": any_formats, "bitops": bitops_formats, "branch": branch_formats, "call": call_formats, @@ -497,7 +471,6 @@ group_map = { "mathops": mathops_formats, "memset": memset_formats, "move": move_formats, - "none": none_formats, "push": push_formats, "pushregs": pushregs_formats, "pop": pop_formats, From e20aed5c5a2aaea758eb9f14916f4906b4cd32bf Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 14:55:29 +0900 Subject: [PATCH 166/360] [gamecode] Change address mode B to entity.field It turned out that address mode B was redundant as C with 0 offset (immediate) was the same (except for the underlying C code of course, but adding st->b is very cheap). This allowed B to be used for entity.field for all transfer operations. Thus instructions 0-3 are now free as load E became load B, and other than the specifics of format codes for statement printing, transfers+lea are unified. --- libs/gamecode/opcodes.py | 87 ++++++++++++++++----------------- libs/gamecode/pr_exec.c | 39 +++------------ libs/gamecode/test/test-lea.c | 2 +- libs/gamecode/test/test-load.c | 32 +++--------- libs/gamecode/test/test-stack.c | 26 ++++++---- libs/gamecode/test/test-store.c | 13 +++-- 6 files changed, 82 insertions(+), 117 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index c8316eb16..40d84c341 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -4,6 +4,7 @@ bitmap_txt = """ 0 0010 mmss push 0 0011 mmss pop 0 1ccc ttss compare +0 0000 00nn 0 1011 nnnn 0 1111 nnnn @@ -34,11 +35,26 @@ bitmap_txt = """ import copy +address_mode = "ABCD" +address_types = [ + "ev_void, ev_invalid", + "ev_entity, ev_field", + "ev_ptr, ev_short", + "ev_ptr, ev_int", +] +#store, pop and lea +store_fmt = [ + "%ga", + "%Ga.%Gb(%Ea)", + "*(%Ga + %sb)", + "*(%Ga + %Gb)", +] +# load and push load_fmt = [ - "%Ga.%Gb(%Ea), %gc", "*%Ga, %gc", - "*(%Ga + %sb), %gc", - "*(%Ga + %Gb), %gc", + "%Ga.%Gb(%Ea)", + "*(%Ga + %sb)", + "*(%Ga + %Gb)", ] branch_fmt = [ "branch %sa (%Oa)", @@ -175,29 +191,26 @@ lea_formats = { "opcode": "OP_LEA_{op_mode[mm]}", "mnemonic": "lea", "opname": "lea", - "format": "{lea_fmt[mm]}", + "format": "{lea_fmt[mm]}, %gc", "widths": "0, 0, 1", - "types": "ev_ptr, ev_ptr, ev_ptr", + "types": "{lea_types[mm]}, ev_ptr", "args": { - "op_mode": "AECD", - "lea_fmt": [ - "%ga, %gc", - "%Ga.%Gb(%Ea), %gc", - "*(%Ga + %sb), %gc", - "*(%Ga + %Gb), %gc", - ], + "op_mode": address_mode, + "lea_fmt": store_fmt, + "lea_types": address_types, }, } load_formats = { "opcode": "OP_LOAD_{op_mode[mm]}_{ss+1}", "mnemonic": "load", "opname": "load", - "format": "{load_fmt[mm]}", + "format": "{load_fmt[mm]}, %gc", "widths": "0, 0, {ss+1}", - "types": "ev_void, ev_void, ev_void", + "types": "{load_types[mm]}, ev_void", "args": { - "op_mode": "EBCD", + "op_mode": address_mode, "load_fmt": load_fmt, + "load_types": address_types, }, } mathops_formats = { @@ -242,15 +255,11 @@ push_formats = { "opname": "push", "format": "{push_fmt[mm]}", "widths": "{ss+1}, 0, 0", - "types": "ev_void, ev_void, ev_invalid", + "types": "{push_types[mm]}, ev_invalid", "args": { - "op_mode": "ABCD", - "push_fmt": [ - "%Ga", - "*%Ga", - "*(%Ga + %sb)", - "*(%Ga + %Gb)", - ], + "op_mode": address_mode, + "push_fmt": load_fmt, + "push_types": address_types, }, } pushregs_formats = { @@ -267,15 +276,11 @@ pop_formats = { "opname": "pop", "format": "{pop_fmt[mm]}", "widths": "{ss+1}, 0, 0", - "types": "ev_void, ev_void, ev_invalid", + "types": "{pop_types[mm]}, ev_invalid", "args": { - "op_mode": "ABCD", - "pop_fmt": [ - "%ga", - "*%Ga", - "*(%Ga + %sb)", - "*(%Ga + %Gb)", - ], + "op_mode": address_mode, + "pop_fmt": store_fmt, + "pop_types": address_types, }, } popregs_formats = { @@ -342,24 +347,14 @@ store_formats = { "opcode": "OP_STORE_{op_mode[mm]}_{ss+1}", "mnemonic": "{store_op[mm]}", "opname": "{store_op[mm]}", - "format": "{store_fmt[mm]}", + "format": "%Gc, {store_fmt[mm]}", "widths": "{ss+1}, 0, {ss+1}", - "types": "{store_types[mm]}", + "types": "{store_types[mm]}, ev_void", "args": { - "op_mode": "ABCD", - "store_fmt": [ - "%Gc, %ga", - "%Gc, *%Ga", - "%Gc, *(%Ga + %sb)", - "%Gc, *(%Ga + %Gb)", - ], + "op_mode": address_mode, + "store_fmt": store_fmt, "store_op": ["assign", "store", "store", "store"], - "store_types": [ - "ev_void, ev_invalid, ev_void", - "ev_ptr, ev_invalid, ev_void", - "ev_ptr, ev_short, ev_void", - "ev_ptr, ev_int, ev_void", - ], + "store_types": address_types, }, } string_formats = { diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 7ca7d6ad9..1e7f9634c 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1759,8 +1759,9 @@ pr_address_mode (progs_t *pr, const dstatement_t *st, int mm_ind) mm_offs = op_a - pr->pr_globals; break; case 1: - // simple pointer dereference: *a - mm_offs = OPA(ptr); + // entity.field (equivalent to OP_LOAD_t_v6p) + pr_ptr_t edict_area = pr->pr_edict_area - pr->pr_globals; + mm_offs = edict_area + OPA(entity) + OPB(field); break; case 2: // constant indexed pointer: *a + b (supports -ve offset) @@ -1770,11 +1771,6 @@ pr_address_mode (progs_t *pr, const dstatement_t *st, int mm_ind) // variable indexed pointer: *a + *b (supports -ve offset) mm_offs = OPA(ptr) + OPB(int); break; - case 4: - // entity.field (equivalent to OP_LOAD_t_v6p) - pr_ptr_t edict_area = pr->pr_edict_area - pr->pr_globals; - mm_offs = edict_area + OPA(entity) + OPB(field); - break; } return pr->pr_globals + mm_offs; } @@ -2767,44 +2763,28 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) pr_opcode_e st_op = st->op & OP_MASK; switch (st_op) { // 0 0000 - case OP_LOAD_E_1: - mm = pr_address_mode (pr, st, 4); - OPC(int) = MM(int); - break; case OP_LOAD_B_1: case OP_LOAD_C_1: case OP_LOAD_D_1: - mm = pr_address_mode (pr, st, (st_op - OP_LOAD_E_1) >> 2); + mm = pr_address_mode (pr, st, (st_op - OP_LOAD_B_1 + 4) >> 2); OPC(int) = MM(int); break; - case OP_LOAD_E_2: - mm = pr_address_mode (pr, st, 4); - OPC(ivec2) = MM(ivec2); - break; case OP_LOAD_B_2: case OP_LOAD_C_2: case OP_LOAD_D_2: - mm = pr_address_mode (pr, st, (st_op - OP_LOAD_E_2) >> 2); + mm = pr_address_mode (pr, st, (st_op - OP_LOAD_B_2 + 4) >> 2); OPC(ivec2) = MM(ivec2); break; - case OP_LOAD_E_3: - mm = pr_address_mode (pr, st, 4); - VectorCopy (&MM(int), &OPC(int)); - break; case OP_LOAD_B_3: case OP_LOAD_C_3: case OP_LOAD_D_3: - mm = pr_address_mode (pr, st, (st_op - OP_LOAD_E_3) >> 2); + mm = pr_address_mode (pr, st, (st_op - OP_LOAD_B_3 + 4) >> 2); VectorCopy (&MM(int), &OPC(int)); break; - case OP_LOAD_E_4: - mm = pr_address_mode (pr, st, 4); - OPC(ivec4) = MM(ivec4); - break; case OP_LOAD_B_4: case OP_LOAD_C_4: case OP_LOAD_D_4: - mm = pr_address_mode (pr, st, (st_op - OP_LOAD_E_4) >> 2); + mm = pr_address_mode (pr, st, (st_op - OP_LOAD_B_4 + 4) >> 2); OPC(ivec4) = MM(ivec4); break; // 0 0001 @@ -3389,15 +3369,12 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) break; // 1 1111 case OP_LEA_A: + case OP_LEA_B: case OP_LEA_C: case OP_LEA_D: mm = pr_address_mode (pr, st, (st_op - OP_LEA_A)); op_c->pointer_var = mm - pr->pr_globals; break; - case OP_LEA_E: - mm = pr_address_mode (pr, st, 4); - op_c->pointer_var = mm - pr->pr_globals; - break; case OP_QV4MUL_F: OPC(vec4) = qvmulf (OPA(vec4), OPB(vec4)); break; diff --git a/libs/gamecode/test/test-lea.c b/libs/gamecode/test/test-lea.c index 1a4f159f7..33e148c16 100644 --- a/libs/gamecode/test/test-lea.c +++ b/libs/gamecode/test/test-lea.c @@ -22,7 +22,7 @@ static dstatement_t lea_statements[] = { {OP(0, 0, 0, OP_LEA_A), 7, 9, 12}, {OP(0, 0, 0, OP_LEA_C), 2, 6, 13}, {OP(0, 0, 0, OP_LEA_D), 2, 6, 14}, - {OP(0, 0, 0, OP_LEA_E), 4, 2, 15}, + {OP(0, 0, 0, OP_LEA_B), 4, 2, 15}, }; test_t tests[] = { diff --git a/libs/gamecode/test/test-load.c b/libs/gamecode/test/test-load.c index e283ced38..986a58163 100644 --- a/libs/gamecode/test/test-load.c +++ b/libs/gamecode/test/test-load.c @@ -30,20 +30,12 @@ static pr_int_t test_globals_expect[] = { 1, 2, 3, 4, }; -static dstatement_t load_E_statements[] = { - {OP(0, 0, 0, OP_LOAD_E_4), 7, 9, 12}, - {OP(0, 0, 0, OP_LOAD_E_3), 7, 8, 16}, - {OP(0, 0, 0, OP_LOAD_E_1), 7, 7, 19}, - {OP(0, 0, 0, OP_LOAD_E_2), 7, 6, 20}, - {OP(0, 0, 0, OP_LOAD_E_2), 7, 5, 22}, -}; - static dstatement_t load_B_statements[] = { - {OP(0, 0, 0, OP_LOAD_B_4), 4, 0, 12}, - {OP(0, 0, 0, OP_LOAD_B_3), 3, 0, 16}, - {OP(0, 0, 0, OP_LOAD_B_1), 2, 0, 19}, - {OP(0, 0, 0, OP_LOAD_B_2), 1, 0, 20}, - {OP(0, 0, 0, OP_LOAD_B_2), 0, 0, 22}, + {OP(0, 0, 0, OP_LOAD_B_4), 7, 9, 12}, + {OP(0, 0, 0, OP_LOAD_B_3), 7, 8, 16}, + {OP(0, 0, 0, OP_LOAD_B_1), 7, 7, 19}, + {OP(0, 0, 0, OP_LOAD_B_2), 7, 6, 20}, + {OP(0, 0, 0, OP_LOAD_B_2), 7, 5, 22}, }; static dstatement_t load_C_statements[] = { @@ -63,17 +55,6 @@ static dstatement_t load_D_statements[] = { }; test_t tests[] = { - { - .desc = "load E", - .num_globals = num_globals (test_globals_init, test_globals_expect), - .num_statements = num_statements (load_E_statements), - .statements = load_E_statements, - .init_globals = test_globals_init, - .expect_globals = test_globals_expect, - // FIXME negative field offsets are not official but work because all - // offset calculations are done in 32-bit and thus wrap anyway - .edict_area = 28, - }, { .desc = "load B", .num_globals = num_globals (test_globals_init, test_globals_expect), @@ -81,6 +62,9 @@ test_t tests[] = { .statements = load_B_statements, .init_globals = test_globals_init, .expect_globals = test_globals_expect, + // FIXME negative field offsets are not official but work because all + // offset calculations are done in 32-bit and thus wrap anyway + .edict_area = 28, }, { .desc = "load C", diff --git a/libs/gamecode/test/test-stack.c b/libs/gamecode/test/test-stack.c index 183e33694..eba5a06d8 100644 --- a/libs/gamecode/test/test-stack.c +++ b/libs/gamecode/test/test-stack.c @@ -81,11 +81,11 @@ static dstatement_t stack_AB_statements[] = { {OP(0, 0, 0, OP_PUSH_A_2), 20, 0, 0}, {OP(0, 0, 0, OP_PUSH_A_2), 22, 0, 0}, - {OP(0, 0, 0, OP_POP_B_2), 0, 0, 0}, - {OP(0, 0, 0, OP_POP_B_2), 1, 0, 0}, - {OP(0, 0, 0, OP_POP_B_1), 2, 0, 0}, - {OP(0, 0, 0, OP_POP_B_3), 3, 0, 0}, - {OP(0, 0, 0, OP_POP_B_4), 4, 0, 0}, + {OP(0, 0, 0, OP_POP_B_2), 7, 5, 0}, + {OP(0, 0, 0, OP_POP_B_2), 7, 6, 0}, + {OP(0, 0, 0, OP_POP_B_1), 7, 7, 0}, + {OP(0, 0, 0, OP_POP_B_3), 7, 8, 0}, + {OP(0, 0, 0, OP_POP_B_4), 7, 9, 0}, }; static dstatement_t stack_AC_statements[] = { @@ -117,11 +117,11 @@ static dstatement_t stack_AD_statements[] = { }; static dstatement_t stack_BA_statements[] = { - {OP(0, 0, 0, OP_PUSH_B_2), 0, 0, 0}, - {OP(0, 0, 0, OP_PUSH_B_2), 1, 0, 0}, - {OP(0, 0, 0, OP_PUSH_B_1), 2, 0, 0}, - {OP(0, 0, 0, OP_PUSH_B_3), 3, 0, 0}, - {OP(0, 0, 0, OP_PUSH_B_4), 4, 0, 0}, + {OP(0, 0, 0, OP_PUSH_B_2), 7, 5, 0}, + {OP(0, 0, 0, OP_PUSH_B_2), 7, 6, 0}, + {OP(0, 0, 0, OP_PUSH_B_1), 7, 7, 0}, + {OP(0, 0, 0, OP_PUSH_B_3), 7, 8, 0}, + {OP(0, 0, 0, OP_PUSH_B_4), 7, 9, 0}, {OP(0, 0, 0, OP_POP_A_4), 12, 0, 0}, {OP(0, 0, 0, OP_POP_A_3), 16, 0, 0}, @@ -176,6 +176,9 @@ test_t tests[] = { .statements = stack_AB_statements, .init_globals = test_globals_init1, .expect_globals = test_globals_expect1, + // FIXME negative field offsets are not official but work because all + // offset calculations are done in 32-bit and thus wrap anyway + .edict_area = 28, }, { .desc = "stack push A pop C", @@ -203,6 +206,9 @@ test_t tests[] = { .statements = stack_BA_statements, .init_globals = test_globals_init2, .expect_globals = test_globals_expect2, + // FIXME negative field offsets are not official but work because all + // offset calculations are done in 32-bit and thus wrap anyway + .edict_area = 28, }, { .desc = "stack push C pop A", diff --git a/libs/gamecode/test/test-store.c b/libs/gamecode/test/test-store.c index dc580f028..5ed5147b8 100644 --- a/libs/gamecode/test/test-store.c +++ b/libs/gamecode/test/test-store.c @@ -39,11 +39,11 @@ static dstatement_t store_A_statements[] = { }; static dstatement_t store_B_statements[] = { - {OP(0, 0, 0, OP_STORE_B_4), 4, 0, 12}, - {OP(0, 0, 0, OP_STORE_B_3), 3, 0, 16}, - {OP(0, 0, 0, OP_STORE_B_1), 2, 0, 19}, - {OP(0, 0, 0, OP_STORE_B_2), 1, 0, 20}, - {OP(0, 0, 0, OP_STORE_B_2), 0, 0, 22}, + {OP(0, 0, 0, OP_STORE_B_4), 7, 9, 12}, + {OP(0, 0, 0, OP_STORE_B_3), 7, 8, 16}, + {OP(0, 0, 0, OP_STORE_B_1), 7, 7, 19}, + {OP(0, 0, 0, OP_STORE_B_2), 7, 6, 20}, + {OP(0, 0, 0, OP_STORE_B_2), 7, 5, 22}, }; static dstatement_t store_C_statements[] = { @@ -78,6 +78,9 @@ test_t tests[] = { .statements = store_B_statements, .init_globals = test_globals_init, .expect_globals = test_globals_expect, + // FIXME negative field offsets are not official but work because all + // offset calculations are done in 32-bit and thus wrap anyway + .edict_area = 28, }, { .desc = "store C", From 74d00d0a3c2c963a107015a546a4aef0c4a88b59 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 15:30:37 +0900 Subject: [PATCH 167/360] [qfcc] Update store statements for change in B mode Ruamoko store instructions are now always indexed and thus need a 0 for unindexed references, but v6 stores still have no-index addressing. --- tools/qfcc/source/statements.c | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index cd9245a93..2e01e5a0c 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -948,7 +948,13 @@ dereference_dst: dst_expr->e.address.offset, &ofs); } else { sblock = statement_subexpr (sblock, dst_expr, &dst); - ofs = 0; + if (options.code.progsversion < PROG_VERSION) { + // v6 and v6p stores don't need an index + ofs = 0; + } else { + // ruamoko stores do need an index + ofs = short_operand (0, e); + } } type = st_ptrassign; } From b2ddae46b2f90b8ef7e3d69444a271502612abc9 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 15:34:43 +0900 Subject: [PATCH 168/360] [qfcc] Show raw opcode when dumping instructions Allows checking the correct instruction has been selected (it's not: getting 4-component instructions instead of 1) --- tools/qfcc/source/opcodes.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index 3815c54e1..82f7c750c 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -361,5 +361,6 @@ opcode_print_statement (pr_uint_t addr, dstatement_t *st) } else { mnemonic = pr_opcodes[st->op].mnemonic; } - printf ("%04x %8s %04x %04x %04x\n", addr, mnemonic, st->a, st->b, st->c); + printf ("%04x (%03x)%-8s %04x %04x %04x\n", + addr, st->op & 0x1ff, mnemonic, st->a, st->b, st->c); } From 854e45485a3fb24ec109d24e147339a403313550 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 16:33:04 +0900 Subject: [PATCH 169/360] [gamecode] Correct the widths for load, store and lea The different addressing modes complicate the width calculations, and lea is particularly fun in that it doesn't care what the width of value is. --- libs/gamecode/opcodes.py | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 40d84c341..ca2f1d836 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -42,6 +42,13 @@ address_types = [ "ev_ptr, ev_short", "ev_ptr, ev_int", ] +address_widths = [ + [ "1, 0", "1, 1", "1, 0", "1, 1", ], + [ "2, 0", "1, 1", "1, 0", "1, 1", ], + [ "3, 0", "1, 1", "1, 0", "1, 1", ], + [ "4, 0", "1, 1", "1, 0", "1, 1", ], + [ "-1, 0", "1, 1", "1, 0", "1, 1", ], +] #store, pop and lea store_fmt = [ "%ga", @@ -192,12 +199,13 @@ lea_formats = { "mnemonic": "lea", "opname": "lea", "format": "{lea_fmt[mm]}, %gc", - "widths": "0, 0, 1", + "widths": "{lea_widths[mm]}, 1", "types": "{lea_types[mm]}, ev_ptr", "args": { "op_mode": address_mode, "lea_fmt": store_fmt, "lea_types": address_types, + "lea_widths": address_widths[4], }, } load_formats = { @@ -205,12 +213,13 @@ load_formats = { "mnemonic": "load", "opname": "load", "format": "{load_fmt[mm]}, %gc", - "widths": "0, 0, {ss+1}", + "widths": "{load_widths[ss][mm]}, {ss+1}", "types": "{load_types[mm]}, ev_void", "args": { "op_mode": address_mode, "load_fmt": load_fmt, "load_types": address_types, + "load_widths": address_widths, }, } mathops_formats = { @@ -348,13 +357,14 @@ store_formats = { "mnemonic": "{store_op[mm]}", "opname": "{store_op[mm]}", "format": "%Gc, {store_fmt[mm]}", - "widths": "{ss+1}, 0, {ss+1}", + "widths": "{store_widths[ss][mm]}, {ss+1}", "types": "{store_types[mm]}, ev_void", "args": { "op_mode": address_mode, "store_fmt": store_fmt, "store_op": ["assign", "store", "store", "store"], "store_types": address_types, + "store_widths": address_widths, }, } string_formats = { From 54d776f243817fb653d985981f83935f96e4e01c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 16:49:07 +0900 Subject: [PATCH 170/360] [qfcc] Take operand width into account Operand width is encoded in the instruction opcode, so the width needs to be accounted for in order to select the correct instruction. With this, my little test generates correct code for the ruamoko ISA (except for return, still fails). --- tools/qfcc/include/statements.h | 1 + tools/qfcc/include/type.h | 1 + tools/qfcc/source/opcodes.c | 65 ++++++++++++++++++++++++++++----- tools/qfcc/source/statements.c | 6 +++ tools/qfcc/source/type.c | 28 +++++++++++++- 5 files changed, 91 insertions(+), 10 deletions(-) diff --git a/tools/qfcc/include/statements.h b/tools/qfcc/include/statements.h index 386dad198..622d7c377 100644 --- a/tools/qfcc/include/statements.h +++ b/tools/qfcc/include/statements.h @@ -68,6 +68,7 @@ typedef struct operand_s { op_type_e op_type; struct type_s *type; ///< possibly override def's/nil's type int size; ///< for structures + int width; ///< for SIMD selection struct expr_s *expr; ///< expression generating this operand void *return_addr; ///< who created this operand union { diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h index 4a65b3384..b8cff36e5 100644 --- a/tools/qfcc/include/type.h +++ b/tools/qfcc/include/type.h @@ -166,6 +166,7 @@ int type_compatible (const type_t *dst, const type_t *src) __attribute__((pure)) int type_assignable (const type_t *dst, const type_t *src); int type_same (const type_t *dst, const type_t *src) __attribute__((pure)); int type_size (const type_t *type) __attribute__((pure)); +int type_width (const type_t *type) __attribute__((pure)); void init_types (void); void chain_initial_types (void); diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index 82f7c750c..9e98fcd26 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -139,6 +139,8 @@ rua_get_hash (const void *_op, void *_tab) hash = ROTL (~op->types[0], 8) + ROTL (~op->types[1], 16) + ROTL (~op->types[2], 24); + hash += ROTL (~op->widths[0], 12) + ROTL (~op->widths[1], 20) + + ROTL (~op->widths[2], 28); return hash + Hash_String (op->opname); } @@ -152,6 +154,9 @@ rua_compare (const void *_opa, const void *_opb, void *unused) cmp = (opa->types[0] == opb->types[0]) && (opa->types[1] == opb->types[1]) && (opa->types[2] == opb->types[2]); + cmp &= (opa->widths[0] == opb->widths[0]) + && (opa->widths[1] == opb->widths[1]) + && (opa->widths[2] == opb->widths[2]); return cmp && !strcmp (opa->opname, opb->opname); } @@ -170,6 +175,12 @@ check_operand_type (etype_t ot1, etype_t ot2) return 0; } +static int +check_operand_width (int ow1, int ow2) +{ + return ((ow1 == -1 && ow2) || ow1 == ow2); +} + pr_ushort_t opcode_get (instruction_t *op) { @@ -219,20 +230,43 @@ v6p_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, return op; } +static int +operand_width (operand_t *op) +{ + if (!op) { + return 0; + } + return op->width; +} + static opcode_t * rua_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, operand_t *op_c) { - opcode_t search_op = {}; + opcode_t search_op = { + .opname = name, + .types = { + op_a ? low_level_type (op_a->type) : ev_invalid, + op_b ? low_level_type (op_b->type) : ev_invalid, + op_c ? low_level_type (op_c->type) : ev_invalid, + }, + .widths = { + operand_width (op_a), + operand_width (op_b), + operand_width (op_c), + }, + }; opcode_t *op; opcode_t *sop; void **op_list; int i; - search_op.opname = name; - search_op.types[0] = op_a ? low_level_type (op_a->type) : ev_invalid; - search_op.types[1] = op_b ? low_level_type (op_b->type) : ev_invalid; - search_op.types[2] = op_c ? low_level_type (op_c->type) : ev_invalid; +#if 0 + printf ("%s [%s %d] [%s %d] [%s %d]\n", search_op.opname, + pr_type_name[search_op.types[0]], search_op.widths[0], + pr_type_name[search_op.types[1]], search_op.widths[1], + pr_type_name[search_op.types[2]], search_op.widths[2]); +#endif op = Hash_FindElement (rua_opcode_type_table, &search_op); if (op) return op; @@ -241,10 +275,23 @@ rua_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, return op; for (i = 0; !op && op_list[i]; i++) { sop = op_list[i]; - if (check_operand_type (sop->types[0], search_op.types[0]) - && check_operand_type (sop->types[1], search_op.types[1]) - && check_operand_type (sop->types[2], search_op.types[2])) - op = sop; + if (!(check_operand_type (sop->types[0], search_op.types[0]) + && check_operand_type (sop->types[1], search_op.types[1]) + && check_operand_type (sop->types[2], search_op.types[2]))) { + continue; + } + if (!(check_operand_width (sop->widths[0], search_op.widths[0]) + && check_operand_width (sop->widths[1], search_op.widths[1]) + && check_operand_width (sop->widths[2], search_op.widths[2]))) { +#if 0 + printf ("%s [%s %d] [%s %d] [%s %d]\n", sop->opname, + pr_type_name[sop->types[0]], sop->widths[0], + pr_type_name[sop->types[1]], sop->widths[1], + pr_type_name[sop->types[2]], sop->widths[2]); +#endif + continue; + } + op = sop; } free (op_list); return op; diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 2e01e5a0c..79c056251 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -426,6 +426,7 @@ nil_operand (type_t *type, expr_t *expr) op = new_operand (op_nil, expr, __builtin_return_address (0)); op->type = type; op->size = type_size (type); + op->width = type_width (type); return op; } @@ -439,6 +440,7 @@ def_operand (def_t *def, type_t *type, expr_t *expr) op = new_operand (op_def, expr, __builtin_return_address (0)); op->type = type; op->size = type_size (type); + op->width = type_width (type); op->def = def; return op; } @@ -458,6 +460,8 @@ value_operand (ex_value_t *value, expr_t *expr) operand_t *op; op = new_operand (op_value, expr, __builtin_return_address (0)); op->type = value->type; + op->size = type_size (value->type); + op->width = type_width (value->type); op->value = value; return op; } @@ -470,6 +474,7 @@ temp_operand (type_t *type, expr_t *expr) op->tempop.type = type; op->type = type; op->size = type_size (type); + op->width = type_width (type); return op; } @@ -544,6 +549,7 @@ alias_operand (type_t *type, operand_t *op, expr_t *expr) aop->alias = op; aop->type = type; aop->size = type_size (type); + aop->width = type_width (type); return aop; } diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index 76a8e5976..a52594af8 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -1007,7 +1007,33 @@ type_size (const type_t *type) case ty_alias: return type_size (type->t.alias.aux_type); } - return 0; + internal_error (0, "invalid type meta: %d", type->meta); +} + +int +type_width (const type_t *type) +{ + switch (type->meta) { + case ty_basic: + if (type->type == ev_ushort || type->type == ev_short) { + return 0; + } + return 1; //FIXME vector should be 3 + case ty_struct: + case ty_union: + return 1; + case ty_enum: + if (!type->t.symtab) + return 0; + return type_width (&type_int); + case ty_array: + return type_width (type->t.array.type); + case ty_class: + return 1; + case ty_alias: + return type_width (type->t.alias.aux_type); + } + internal_error (0, "invalid type meta: %d", type->meta); } static void From c39558efaa733b4cc088737893b74e32c4dda22c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 17:27:56 +0900 Subject: [PATCH 171/360] [gamecode] Audit the widths of rest of the instructions I can't test them properly until I get qfcc up and running with basic ruamoko code, but they are at least more correct than they were. --- libs/gamecode/opcodes.py | 50 ++++++++++++++++++++++------------------ 1 file changed, 27 insertions(+), 23 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index ca2f1d836..8b800135f 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -99,7 +99,7 @@ branch_formats = { "mnemonic": "{op_cond[c*4+cc]}", "opname": "{op_cond[c*4+cc]}", "format": "{cond_fmt[c*4+cc]}{branch_fmt[0]}", - "widths": "{cond_widths[c*4+cc]}", + "widths": "0, 0, 1", "types": "ev_short, ev_invalid, ev_int", "args": { "op_mode": "ABCD", @@ -107,16 +107,6 @@ branch_formats = { "ifnz", "ifae", "ifbe", None], "branch_fmt": branch_fmt, "cond_fmt": ["%Gc ", "%Gc ", "%Gc ", "", "%Gc ", "%Gc ", "%Gc ", ""], - "cond_widths": [ - "0, 0, 1", - "0, 0, 1", - "0, 0, 1", - "0, 0, 0", - "0, 0, 1", - "0, 0, 1", - "0, 0, 1", - "0, 0, 0", - ], }, } call_formats = { @@ -124,7 +114,7 @@ call_formats = { "mnemonic": "call", "opname": "call", "format": "{call_fmt[mm]}", - "widths": "0, 0, 0", + "widths": "{call_widths[mm]}, 0", "types": "ev_void, ev_void, ev_void", "args": { "op_mode": ".BCD", @@ -134,6 +124,7 @@ call_formats = { "%Ga[%sb], %gc", "%Ga[%Gb], %gc", ], + "call_widths": [ None, "1, 0", "1, 0", "1, 1" ] }, } compare_formats = { @@ -165,7 +156,7 @@ convert_formats = { "mnemonic": "conv", "opname": "conv", "format": "%Ga %Cb %gc", - "widths": "1, 0, 1", + "widths": "-1, 0, -1", "types": "ev_void, ev_short, ev_void", } hops_formats = { @@ -173,7 +164,7 @@ hops_formats = { "mnemonic": "hops", "opname": "hops", "format": "%Ga %Hb %gc", - "widths": "1, 0, 1", + "widths": "-1, 0, 1", "types": "ev_void, ev_short, ev_void", } jump_formats = { @@ -181,7 +172,7 @@ jump_formats = { "mnemonic": "jump", "opname": "jump", "format": "{jump_fmt[mm]}", - "widths": "0, 0, 0", + "widths": "{jump_widths[mm]}, 0", "types": "{jump_types[mm]}", "args": { "op_mode": "ABCD", @@ -192,6 +183,7 @@ jump_formats = { "ev_ptr, ev_short, ev_invalid", "ev_ptr, ev_int, ev_invalid", ], + "jump_widths": [ "0, 0", "1, 0", "1, 0", "1, 1" ] }, } lea_formats = { @@ -239,11 +231,17 @@ memset_formats = { "mnemonic": "memset.{op_memset[oo]}", "opname": "memset", "format": "{memset_fmt[oo]}", - "widths": "0, 0, 0", + "widths": "{memset_widths[oo]}", "types": "ev_int, ev_void, ev_void", "args": { "op_memset": ["i", "p", "pi", None], "memset_fmt": ["%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc", None], + "memset_widths": [ + "1, 0, -1", + "1, 1, 1", + "1, 0, 1", + None, + ], }, } move_formats = { @@ -251,11 +249,17 @@ move_formats = { "mnemonic": "memset.{op_move[oo]}", "opname": "memset", "format": "{move_fmt[oo]}", - "widths": "0, 0, 0", + "widths": "{move_widths[oo]}", "types": "ev_int, ev_void, ev_void", "args": { "op_move": ["i", "p", "pi", None], "move_fmt": ["%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc", None], + "move_widths": [ + "-1, 0, -1", + "1, 1, 1", + "1, 0, 1", + None, + ], }, } push_formats = { @@ -331,7 +335,7 @@ statef_formats = { "mnemonic": "state.{state[c]}", "opname": "state", "format": "{state_fmt[c]}", - "widths": "1, 1, 1", + "widths": "1, 1, {c}", "types": "ev_float, ev_func, {state_types[c]}", "args": { "state": ["ft", "ftt"], @@ -344,7 +348,7 @@ stated_formats = { "mnemonic": "state.{state[c]}", "opname": "state", "format": "{state_fmt[c]}", - "widths": "1, 1, 1", + "widths": "1, 1, {c}", "types": "ev_float, ev_func, {state_types[c]}", "args": { "state": ["dt", "dtt"], @@ -372,7 +376,7 @@ string_formats = { "mnemonic": "{op_str[o*4+oo]}.s", "opname": "{op_str[o*4+oo]}", "format": "{str_fmt[o*4+oo]}", - "widths": "1, 1, 1", + "widths": "1, {(o*4+oo)<7 and 1 or 0}, 1", "types": "{str_types[o*4+oo]}", "args": { "op_str": ["eq", "lt", "gt", "add", "cmp", "ge", "le", "not"], @@ -414,7 +418,7 @@ return_formats = { "opcode": "OP_RETURN", "mnemonic": "return", "opname": "return", - "widths": "0, 0, 0", # width specified by st->c + "widths": "-1, -1, 0", # width specified by st->c "format": "FIXME", "types": "ev_void, ev_void, ev_void", } @@ -458,8 +462,8 @@ with_formats = { "mnemonic": "with", "opname": "with", "format": "%sa, %sb, %sc", - "widths": "0, 0, 0", - "types": "ev_void, ev_void, ev_void", + "widths": "0, -1, 0", + "types": "ev_short, ev_void, ev_short", } group_map = { From 5f66bfe887342d33e54e4bbe1e19e04bdc3243a7 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 18:37:28 +0900 Subject: [PATCH 172/360] [gamecode] Update printed opcode width Opcodes now need 3 hex digits (hexits?) to print. --- libs/gamecode/pr_debug.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 32f6a8dd9..794005174 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -1586,7 +1586,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) dasprintf (res->line, "%04x ", addr); if (pr_debug->int_val > 2) { dasprintf (res->line, - "%02x %04x(%8s)[%d] %04x(%8s)[%d] %04x(%8s)[%d]\t", + "%03x %04x(%8s)[%d] %04x(%8s)[%d] %04x(%8s)[%d]\t", s->op, s->a, pr_type_name[op_type[0]], op_width[0], s->b, pr_type_name[op_type[1]], op_width[1], From 6487fe7ea74a64940109cdfb039c0ab6ca833f29 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 18:39:06 +0900 Subject: [PATCH 173/360] [qfcc] Allow -1 width to match with 0 I initially wanted them to be separate, but return (and other instructions where width is encoded in one of the operands) made that difficult. --- tools/qfcc/source/opcodes.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index 9e98fcd26..7687851d9 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -178,7 +178,7 @@ check_operand_type (etype_t ot1, etype_t ot2) static int check_operand_width (int ow1, int ow2) { - return ((ow1 == -1 && ow2) || ow1 == ow2); + return (ow1 == -1 || ow1 == ow2); } pr_ushort_t From 2b7a8387e7dc75d7b461c57f8ca1c2c34c960a1d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 18:40:55 +0900 Subject: [PATCH 174/360] [qfcc] Get void return statements working My little test program now builds with the Ruamoko ISA :) void cp (int *dst, int *src, int count) { while (count--) { *dst++ = *src++; } } Calls are broken (unimplemented), and non-void returns are not likely to work either (only partially implemented). --- tools/qfcc/source/dags.c | 4 +++- tools/qfcc/source/flow.c | 24 +++++++++++++++++++----- tools/qfcc/source/statements.c | 26 +++++++++++++++++++++----- 3 files changed, 43 insertions(+), 11 deletions(-) diff --git a/tools/qfcc/source/dags.c b/tools/qfcc/source/dags.c index 5b3a64b3d..d4a7b4fbe 100644 --- a/tools/qfcc/source/dags.c +++ b/tools/qfcc/source/dags.c @@ -452,7 +452,9 @@ dagnode_set_edges (dag_t *dag, dagnode_t *n) int first_param = 0; flowvar_t **flowvars = dag->flownode->graph->func->vars; - if (!strncmp (n->label->opcode, "rcall", 5)) { + if (!strcmp (n->label->opcode, "call")) { + internal_error (0, "not implemented"); + } else if (!strncmp (n->label->opcode, "rcall", 5)) { num_params = n->label->opcode + 6; first_param = 2; } else if (!strncmp (n->label->opcode, "call", 4)) { diff --git a/tools/qfcc/source/flow.c b/tools/qfcc/source/flow.c index 5ed2022da..1cbf057d8 100644 --- a/tools/qfcc/source/flow.c +++ b/tools/qfcc/source/flow.c @@ -1257,15 +1257,29 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, } break; case st_func: - if (strcmp (s->opcode, "return") == 0 - || strcmp (s->opcode, "done") == 0) { - flow_add_op_var (use, s->opa, 1); - } else if (strcmp (s->opcode, "return_v") == 0) { + if (statement_is_return (s)) { + if (s->opc) { + // ruamoko + // opc always short + short ret_mode = s->opc->value->v.short_val; + // -1 is void + // FIXME size and addressing + if (ret_mode >= 0) { + flow_add_op_var (use, s->opa, 1); + } + } else { + // v6/v6p + if (s->opa) { + flow_add_op_var (use, s->opa, 1); + } + } if (use) { flow_add_op_var (use, &flow_params[0].op, 1); } } - if (strncmp (s->opcode, "call", 4) == 0) { + if (strcmp (s->opcode, "call") == 0) { + internal_error (s->expr, "not implemented"); + } else if (strncmp (s->opcode, "call", 4) == 0) { start = 0; calln = s->opcode[5] - '0'; flow_add_op_var (use, s->opa, 1); diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 79c056251..354f1d1db 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1129,9 +1129,18 @@ statement_return (sblock_t *sblock, expr_t *e) } } s = new_statement (st_func, opcode, e); - if (e->e.retrn.ret_val) { - s->opa = return_operand (get_type (e->e.retrn.ret_val), e); - sblock = statement_subexpr (sblock, e->e.retrn.ret_val, &s->opa); + if (options.code.progsversion < PROG_VERSION) { + if (e->e.retrn.ret_val) { + s->opa = return_operand (get_type (e->e.retrn.ret_val), e); + sblock = statement_subexpr (sblock, e->e.retrn.ret_val, &s->opa); + } + } else { + if (e->e.retrn.ret_val) { + } else { + s->opa = short_operand (0, e); + s->opb = short_operand (0, e); + s->opc = short_operand (-1, e); + } } sblock_add_statement (sblock, s); sblock->next = new_sblock (); @@ -2134,8 +2143,15 @@ check_final_block (sblock_t *sblock) sblock = sblock->next; } s = new_statement (st_func, "return", 0); - if (options.traditional || options.code.progsversion == PROG_ID_VERSION) { - s->opa = return_operand (&type_void, 0); + if (options.code.progsversion == PROG_VERSION) { + s->opa = short_operand (0, 0); + s->opb = short_operand (0, 0); + s->opc = short_operand (-1, 0); + } else { + if (options.traditional + || options.code.progsversion == PROG_ID_VERSION) { + s->opa = return_operand (&type_void, 0); + } } sblock_add_statement (sblock, s); } From 17dfd1492f4a124cb57194eba2346e3e41960e20 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 20:54:12 +0900 Subject: [PATCH 175/360] [qfcc] Make virtual defspaces useful for highwater allocation This seems to be the most reasonable approach to allocating space for function call parameters without using push and pop (or adding to the stack pointer), though it's probably good even when using push and pop to help keep things aligned. --- tools/qfcc/include/defspace.h | 57 ++++++++++++++++++++++++++++++++-- tools/qfcc/source/defspace.c | 55 +++++++++++++++++++++++++++----- tools/qfcc/source/statements.c | 8 +++++ 3 files changed, 110 insertions(+), 10 deletions(-) diff --git a/tools/qfcc/include/defspace.h b/tools/qfcc/include/defspace.h index 6e839ce67..eea13bf71 100644 --- a/tools/qfcc/include/defspace.h +++ b/tools/qfcc/include/defspace.h @@ -43,7 +43,8 @@ typedef enum { ds_backed, ///< data space is globally addressable (near/far/type) and ///< has backing store ds_virtual, ///< data space has no backing store (local vars, entity - ///< fields) + ///< fields) defspace_t::max_size reflects the highest + ///< address allocated } ds_type_t; /** Represent a block of memory in the progs data space. @@ -56,7 +57,8 @@ typedef struct defspace_s { struct def_s **def_tail; ///< for appending to \a defs pr_type_t *data; ///< backing memory for this space int size; ///< current high-water mark for alloced data - int max_size; ///< size of backing memory + int max_size; ///< size of backing memory, or highwater mark + ///< for ds_virtual /** Grow the backing memory of the defspace. This function is called when more memory is needed for the space. @@ -168,6 +170,57 @@ void defspace_free_loc (defspace_t *space, int ofs, int size); */ int defspace_add_data (defspace_t *space, pr_type_t *data, int size); +/** Allocate a block of data from the end of the defspace. + + If memory cannot be allocated (there is no free space in the currently + available memory and defspace_t::grow is null), then an internal error + will be generated. + + \param space The space from which to allocate data. + \param size The amount of pr_type_t words to allocated. int and float + need 1 word, vector 3 words, and quaternion 4. + \return The offset of the first word of the freshly allocated + space. May be 0 if the allocated space is at the beginning + of the defspace. +*/ +int defspace_alloc_highwater (defspace_t *space, int size); + +/** Allocate an aligned block of data from the end of the defspace. + + Any unallocated holes in the defspace are ignored, even if the hole is + at the end of the defspace. However, any holes created by the padding + required for aligning the block will be available to defspace_alloc_loc() + and defspace_alloc_aligned_loc(). + + If memory cannot be allocated (there is no free space in the currently + available memory and defspace_t::grow is null), then an internal error + will be generated. + + \param space The space from which to allocate data. + \param size The amount of pr_type_t words to allocated. int and float + need 1 word, vector 3 words, and quaternion 4. + \param alignment The alignment of the allocated space. + \return The offset of the first word of the freshly allocated + space. May be 0 if the allocated space is at the beginning + of the defspace. +*/ +int defspace_alloc_aligned_highwater (defspace_t *space, int size, + int alignment); +/** Reset a defspace, freeing all allocated memory. + + defspace_t::max_size is not affected. This allows the defspace to be used + to find the larged block of memory required for a set of operations (eg, + the largest parameter block required in a function for all its calls + allowing the stack to remain constant instead of using many push/pop + operations. Note that this works best with ds_virtual defspaces. + + If the defspace has backing memory (ds_backed), the memory is not freed, + but it is zeroed so any new allocations will contain zeroed memory. + + \param space The space to be reset. +*/ +void defspace_reset (defspace_t *space); + ///@} #endif//__defspace_h diff --git a/tools/qfcc/source/defspace.c b/tools/qfcc/source/defspace.c index 1cfe572c3..5bae41bff 100644 --- a/tools/qfcc/source/defspace.c +++ b/tools/qfcc/source/defspace.c @@ -105,14 +105,9 @@ grow_space_global (defspace_t *space) static int grow_space_virtual (defspace_t *space) { - int size; - - if (space->size <= space->max_size) - return 1; - - size = space->size + GROW; - size -= size % GROW; - space->max_size = size; + if (space->size > space->max_size) { + space->max_size = space->size; + } return 1; } @@ -208,6 +203,7 @@ defspace_alloc_aligned_loc (defspace_t *space, int size, int alignment) internal_error (0, "unable to allocate %d words", size); } if (pad) { + // mark the padding as free *l = new_locref (ofs, pad, 0); } return ofs + pad; @@ -271,3 +267,46 @@ defspace_add_data (defspace_t *space, pr_type_t *data, int size) memcpy (space->data + loc, data, size * sizeof (pr_type_t)); return loc; } + +int +defspace_alloc_highwater (defspace_t *space, int size) +{ + return defspace_alloc_aligned_highwater (space, size, 1); +} + +int +defspace_alloc_aligned_highwater (defspace_t *space, int size, int alignment) +{ + if (size <= 0) + internal_error (0, "invalid number of words requested: %d", size); + if (alignment <= 0) + internal_error (0, "invalid alignment requested: %d", alignment); + + int ofs = space->size; + int pad = alignment * ((ofs + alignment - 1) / alignment) - ofs; + space->size += size + pad; + if (space->size > space->max_size) { + if (!space->grow || !space->grow (space)) + internal_error (0, "unable to allocate %d words", size); + } + locref_t **l = &space->free_locs; + if (pad) { + // mark the padding as free + *l = new_locref (ofs, pad, 0); + } + return ofs + pad; +} + +void +defspace_reset (defspace_t *space) +{ + space->size = 0; + while (space->free_locs) { + locref_t *l = space->free_locs; + space->free_locs = l->next; + del_locref (l); + } + if (space->data) { + memset (space->data, 0, space->max_size * sizeof (pr_type_t)); + } +} diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 354f1d1db..756b38492 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1136,6 +1136,14 @@ statement_return (sblock_t *sblock, expr_t *e) } } else { if (e->e.retrn.ret_val) { + expr_t *ret_val = e->e.retrn.ret_val; + type_t *ret_type = get_type (ret_val); + if (is_indirect (ret_val)) { + } else { + sblock = statement_subexpr (sblock, ret_val, &s->opa); + s->opb = short_operand (0, e); + s->opc = short_operand (type_size (ret_type) - 1, e); + } } else { s->opa = short_operand (0, e); s->opb = short_operand (0, e); From b8b47aaf547e8ea2983e31549ea1719602e54f49 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 20 Jan 2022 22:27:10 +0900 Subject: [PATCH 176/360] [qfcc] Give finish_function the finishing blow It's been twitching for over ten years, time to put it out of its misery. --- tools/qfcc/include/function.h | 1 - tools/qfcc/source/function.c | 7 ------- 2 files changed, 8 deletions(-) diff --git a/tools/qfcc/include/function.h b/tools/qfcc/include/function.h index 4f8fa83e7..667cfb5ba 100644 --- a/tools/qfcc/include/function.h +++ b/tools/qfcc/include/function.h @@ -146,7 +146,6 @@ function_t *build_code_function (struct symbol_s *fsym, function_t *build_builtin_function (struct symbol_s *sym, struct expr_s *bi_val, int far, enum storage_class_e storage); -void finish_function (function_t *f); void emit_function (function_t *f, struct expr_s *e); int function_parms (function_t *f, byte *parm_size); void clear_functions (void); diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index b20d38cf5..4840fb41f 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -646,7 +646,6 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements) statements = state_expr; } emit_function (fsym->s.func, statements); - finish_function (fsym->s.func); return fsym->s.func; } @@ -692,7 +691,6 @@ build_builtin_function (symbol_t *sym, expr_t *bi_val, int far, sym->s.func->builtin = bi; reloc_def_func (sym->s.func, sym->s.func->def); build_function (sym); - finish_function (sym->s.func); // for debug info build_scope (sym, current_symtab); @@ -700,11 +698,6 @@ build_builtin_function (symbol_t *sym, expr_t *bi_val, int far, return sym->s.func; } -void -finish_function (function_t *f) -{ -} - void emit_function (function_t *f, expr_t *e) { From ac785ca7520ed477ec491db066d112eda55dc2cc Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 00:44:04 +0900 Subject: [PATCH 177/360] [qwaq] Send app focus event on startup Terminal apps effectively always have focus (unless I find a way to know when an xterm loses/gains focus). Fixes input-app not updating on evdev events. --- ruamoko/qwaq/builtins/term-input.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/ruamoko/qwaq/builtins/term-input.c b/ruamoko/qwaq/builtins/term-input.c index 7ebbde1d2..697cd2e7c 100644 --- a/ruamoko/qwaq/builtins/term-input.c +++ b/ruamoko/qwaq/builtins/term-input.c @@ -860,6 +860,12 @@ bi_init_input (progs_t *pr) qwaq_input_init (res); res->initialized = 1; create_thread (qwaq_input_thread, res); + + IE_event_t event = { + .type = ie_app_gain_focus, + .when = Sys_LongTime (), + }; + IE_Send_Event (&event); } static builtin_t builtins[] = { From 4b87d24737843acff65dda9a21a3bef78de5cad5 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 10:07:35 +0900 Subject: [PATCH 178/360] [gamecode] Correct call's operator types --- libs/gamecode/opcodes.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 8b800135f..37ca5c2e2 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -115,7 +115,7 @@ call_formats = { "opname": "call", "format": "{call_fmt[mm]}", "widths": "{call_widths[mm]}, 0", - "types": "ev_void, ev_void, ev_void", + "types": "{call_types[mm]}, ev_void", "args": { "op_mode": ".BCD", "call_fmt": [ @@ -124,6 +124,12 @@ call_formats = { "%Ga[%sb], %gc", "%Ga[%Gb], %gc", ], + "call_types": [ + None, + "ev_void, ev_invalid", + "ev_ptr, ev_short", + "ev_ptr, ev_int", + ], "call_widths": [ None, "1, 0", "1, 0", "1, 1" ] }, } From 578314c5a3a1ed2b5c899494a79c1b9de23cbf24 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 10:09:02 +0900 Subject: [PATCH 179/360] [gamecode] Use a buffer for discarded return values Due to how OP_RETURN works, a destination is required for any function returning data, but the caller may not have allocated any space for the value. Thus the VM maintains a buffer into which the data can be put and ignored. It also makes a good place for return values when the engine calls Ruamoko code as trusting progs code with return sizes seems like a recipe for disaster, especially if the return location is on the C stack. --- include/QF/progs.h | 2 ++ libs/gamecode/pr_exec.c | 3 +++ 2 files changed, 5 insertions(+) diff --git a/include/QF/progs.h b/include/QF/progs.h index f9cf97b32..02cbb0229 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1896,6 +1896,8 @@ struct progs_s { pr_type_t *pr_real_params[MAX_PARMS]; int pr_param_size; ///< covers both params and return int pr_param_alignment; ///< covers both params and return + pr_type_t pr_return_buffer[32];///< for discarded return values + ///< or returning values to C ///@} /// \name edicts diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 1e7f9634c..15885244c 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -427,6 +427,9 @@ PR_CallFunction (progs_t *pr, pr_func_t fnum, pr_type_t *return_ptr) if (!fnum) PR_RunError (pr, "NULL function"); + if (!return_ptr || return_ptr == pr->pr_globals) { + return_ptr = pr->pr_return_buffer; + } f = pr->function_table + fnum; if (f->first_statement < 0) { // negative statements are built in functions From 16a203c643b51f8fa3e6dadeceb706c6763c5f0c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 10:12:50 +0900 Subject: [PATCH 180/360] [gamecode] Partially implement conversion code debug The code is simply printed in octal for now, but it's better than breaking the rest of the format string. --- libs/gamecode/pr_debug.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 794005174..0a3d00e8b 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -1683,6 +1683,9 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) str = dsprintf (res->dva, "%04x", addr + (short) opval); break; + case 'C': + str = dsprintf (res->dva, "%03o", opval); + break; case 'E': { edict_t *ed = 0; From 479ec07fd449d9c0ea27efa186796ef8de8ece3c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 10:14:14 +0900 Subject: [PATCH 181/360] [qfcc] Implement ruamoko conversion instructions Thanks to me having done something right 20 years ago, that was pretty easy :). The two boolean types aren't supported yet because I haven't decided on just how to represent their types in qfcc. --- tools/qfcc/source/statements.c | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 756b38492..bc4cb396b 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1318,6 +1318,17 @@ expr_expr (sblock_t *sblock, expr_t *e, operand_t **op) return sblock; } +static int type_map[ev_type_count] = { + [ev_int] = 0, + [ev_float] = 1, + [ev_long] = 2, + [ev_double] = 3, + [ev_uint] = 4, + //[ev_bool32] = 5, + [ev_ulong] = 6, + //[ev_bool64] = 7, +}; + static sblock_t * expr_cast (sblock_t *sblock, expr_t *e, operand_t **op) { @@ -1332,6 +1343,13 @@ expr_cast (sblock_t *sblock, expr_t *e, operand_t **op) *op = temp_operand (e->e.expr.type, e); s = new_statement (st_expr, "conv", e); s->opa = src; + if (options.code.progsversion == PROG_VERSION) { + int from = type_map[src_type->type]; + int to = type_map[type->type]; + int width = type_width (src_type) - 1; + int conv = (width << 6) | (from << 3) | to; + s->opb = short_operand (conv, e); + } s->opc = *op; sblock_add_statement (sblock, s); } else { From a19349b242bf1d698928ba916fd4fa2d5f32baa9 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 10:16:54 +0900 Subject: [PATCH 182/360] [qfcc] Allow 0 sized highwater allocations in defspaces This turned out to be needed for functions with no parameters (or no locals). --- tools/qfcc/source/defspace.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/qfcc/source/defspace.c b/tools/qfcc/source/defspace.c index 5bae41bff..a704b45a3 100644 --- a/tools/qfcc/source/defspace.c +++ b/tools/qfcc/source/defspace.c @@ -277,7 +277,7 @@ defspace_alloc_highwater (defspace_t *space, int size) int defspace_alloc_aligned_highwater (defspace_t *space, int size, int alignment) { - if (size <= 0) + if (size < 0) internal_error (0, "invalid number of words requested: %d", size); if (alignment <= 0) internal_error (0, "invalid alignment requested: %d", alignment); From 7bc1396358af85c4faef837bfde35863aa9f3fc5 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 10:20:02 +0900 Subject: [PATCH 183/360] [qfcc] Split the function defspace into three spaces Since Ruamoko now uses the stack for parameters and locals, parameters need to come after locals in the address space (instead of before, as in v6 progs). Thus use separate spaces for parameters and locals regardless of the target, then stitch them together appropriately for the target. The third space is used for allocating stack space for arguments to called functions. It us not used for v6 progs, and comes before locals in Ruamoko progs. Other than the return value, and optimization (ice, not implemented) calls in Ruamoko look like they'll work. --- tools/qfcc/include/function.h | 29 +++++++++-- tools/qfcc/source/def.c | 2 +- tools/qfcc/source/flow.c | 2 +- tools/qfcc/source/function.c | 89 ++++++++++++++++++++++++++++------ tools/qfcc/source/obj_file.c | 12 ++--- tools/qfcc/source/qc-parse.y | 8 +-- tools/qfcc/source/qp-parse.y | 8 +-- tools/qfcc/source/statements.c | 45 ++++++++++++++++- 8 files changed, 157 insertions(+), 38 deletions(-) diff --git a/tools/qfcc/include/function.h b/tools/qfcc/include/function.h index 667cfb5ba..3b04bb9e5 100644 --- a/tools/qfcc/include/function.h +++ b/tools/qfcc/include/function.h @@ -73,13 +73,32 @@ typedef struct function_s { struct def_s *temp_defs[4]; ///< freed temp vars (by size) struct def_s *def; ///< output def holding function number struct symbol_s *sym; ///< internal symbol for this function - /** Root scope symbol table of the function. + /** \name Local data space - Sub-scope symbol tables are not directly accessible, but all defs - created in the function's local data space are recorded in the root - scope symbol table's defspace. + The function parameters form the root scope for the function. Its + defspace is separate from the locals defspace so that it can be moved + to the beginning of locals space for v6 progs, and too the end (just + above the stack pointer on entry to the function) for Ruamoko progs. + + The locals scope is a direct child of the parameters scope, and any + sub-scope symbol tables are not directly accessible, but all defs + other than function call arugments created in the function's local + data space are recorded in the root local scope symbol table's + defspace. + + The arguments defspace is not used for v6 progs. It is used as a + highwater allocator for the arguments to all calls made by the + funciton, with the arguments to separate functions overlapping each + other. + + Afther the function has been emitted, locals, arguments and possibly + parameters will be merged into the one defspace. */ - struct symtab_s *symtab; + ///@{ + struct symtab_s *parameters; ///< Root scope symbol table + struct symtab_s *locals; ///< Actual local variables + struct defspace_s *arguments; ///< Space for called function arguments + ///@} struct symtab_s *label_scope; struct reloc_s *refs; ///< relocation targets for this function struct expr_s *var_init; diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c index 449db7320..5f6947c37 100644 --- a/tools/qfcc/source/def.c +++ b/tools/qfcc/source/def.c @@ -204,7 +204,7 @@ def_t * temp_def (type_t *type) { def_t *temp; - defspace_t *space = current_func->symtab->space; + defspace_t *space = current_func->locals->space; int size = type_size (type); int alignment = type->alignment; diff --git a/tools/qfcc/source/flow.c b/tools/qfcc/source/flow.c index 1cbf057d8..8bcd4bbeb 100644 --- a/tools/qfcc/source/flow.c +++ b/tools/qfcc/source/flow.c @@ -609,7 +609,7 @@ flow_build_vars (function_t *func) // set up pseudo address space for temp vars so accessing tmp vars // though aliases analyses correctly - func->pseudo_addr = func->num_statements + func->symtab->space->size; + func->pseudo_addr = func->num_statements + func->locals->space->size; func->num_vars = 0; // incremented by add_operand // first, add .return and .param_[0-7] as they are always needed diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index 4840fb41f..bfc1da059 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -488,16 +488,23 @@ build_scope (symbol_t *fsym, symtab_t *parent) param_t *p; symbol_t *args = 0; symbol_t *param; - symtab_t *symtab; - symtab_t *cs = current_symtab; + symtab_t *parameters; + symtab_t *locals; + symtab_t *cs = current_symtab;//FIXME check_function (fsym); - symtab = new_symtab (parent, stab_local); - fsym->s.func->symtab = symtab; fsym->s.func->label_scope = new_symtab (0, stab_local); - symtab->space = defspace_new (ds_virtual); - current_symtab = symtab; + + parameters = new_symtab (parent, stab_local); + parameters->space = defspace_new (ds_virtual); + fsym->s.func->parameters = parameters; + + locals = new_symtab (parameters, stab_local); + locals->space = defspace_new (ds_virtual); + fsym->s.func->locals = locals; + + current_symtab = locals;//FIXME if (!fsym->s.func) { internal_error (0, "function %s not defined", fsym->name); @@ -507,7 +514,7 @@ build_scope (symbol_t *fsym, symtab_t *parent) } if (fsym->s.func->type->t.func.num_params < 0) { args = new_symbol_type (".args", &type_va_list); - initialize_def (args, 0, symtab->space, sc_param); + initialize_def (args, 0, parameters->space, sc_param); } for (p = fsym->params, i = 0; p; p = p->next) { @@ -520,14 +527,14 @@ build_scope (symbol_t *fsym, symtab_t *parent) p->name = save_string (""); } param = new_symbol_type (p->name, p->type); - initialize_def (param, 0, symtab->space, sc_param); + initialize_def (param, 0, parameters->space, sc_param); i++; } if (args) { while (i < MAX_PARMS) { param = new_symbol_type (va (0, ".par%d", i), &type_param); - initialize_def (param, 0, symtab->space, sc_param); + initialize_def (param, 0, parameters->space, sc_param); i++; } } @@ -628,11 +635,32 @@ build_function (symbol_t *fsym) if (func_type->t.func.num_params > MAX_PARMS) { error (0, "too many params"); } - // FIXME -// f->def->constant = 1; -// f->def->nosave = 1; -// f->def->initialized = 1; -// G_FUNCTION (f->def->ofs) = f->function_num; +} + +static void +merge_spaces (defspace_t *dst, defspace_t *src, int alignment) +{ + int offset; + + for (def_t *def = src->defs; def; def = def->next) { + if (def->type->alignment > alignment) { + alignment = def->type->alignment; + } + } + offset = defspace_alloc_aligned_highwater (dst, src->size, alignment); + for (def_t *def = src->defs; def; def = def->next) { + def->offset += offset; + def->space = dst; + } + + if (src->defs) { + *dst->def_tail = src->defs; + dst->def_tail = src->def_tail; + src->def_tail = &src->defs; + *src->def_tail = 0; + } + + defspace_delete (src); } function_t * @@ -645,7 +673,35 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements) state_expr->next = statements; statements = state_expr; } - emit_function (fsym->s.func, statements); + if (options.code.progsversion == PROG_VERSION) { + } + function_t *func = fsym->s.func; + emit_function (func, statements); + if (options.code.progsversion < PROG_VERSION) { + // stitch parameter and locals data together with parameters coming + // first + defspace_t *space = defspace_new (ds_virtual); + + merge_spaces (space, func->parameters->space, 1); + func->parameters->space = space; + + merge_spaces (space, func->locals->space, 1); + func->locals->space = space; + } else { + defspace_t *space = defspace_new (ds_virtual); + + if (func->arguments) { + func->arguments->size = func->arguments->max_size; + merge_spaces (space, func->arguments, 4); + func->arguments = 0; + } + + merge_spaces (space, func->locals->space, 4); + func->locals->space = space; + + merge_spaces (space, func->parameters->space, 4); + func->parameters->space = space; + } return fsym->s.func; } @@ -694,7 +750,8 @@ build_builtin_function (symbol_t *sym, expr_t *bi_val, int far, // for debug info build_scope (sym, current_symtab); - sym->s.func->symtab->space->size = 0; + sym->s.func->parameters->space->size = 0; + sym->s.func->locals->space = sym->s.func->parameters->space; return sym->s.func; } diff --git a/tools/qfcc/source/obj_file.c b/tools/qfcc/source/obj_file.c index a9f562984..17ba70080 100644 --- a/tools/qfcc/source/obj_file.c +++ b/tools/qfcc/source/obj_file.c @@ -171,9 +171,9 @@ qfo_count_function_stuff (qfo_t *qfo, function_t *functions) for (func = functions; func; func = func->next) { qfo->num_funcs++; qfo->num_relocs += count_relocs (func->refs); - if (func->symtab && func->symtab->space) { + if (func->locals && func->locals->space) { qfo->num_spaces++; - qfo_count_space_stuff (qfo, func->symtab->space); + qfo_count_space_stuff (qfo, func->locals->space); } } } @@ -306,10 +306,10 @@ qfo_encode_functions (qfo_t *qfo, qfo_def_t **defs, qfo_reloc_t **relocs, if (f->builtin) // FIXME redundant q->code = -f->builtin; q->def = f->def->qfo_def; - if (f->symtab && f->symtab->space) { - space->id = f->symtab->space->qfo_space; - qfo_init_data_space (qfo, defs, relocs, space++, f->symtab->space); - q->locals_space = f->symtab->space->qfo_space; + if (f->locals && f->locals->space) { + space->id = f->locals->space->qfo_space; + qfo_init_data_space (qfo, defs, relocs, space++, f->locals->space); + q->locals_space = f->locals->space->qfo_space; } q->line_info = f->line_info; q->relocs = *relocs - qfo->relocs; diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index a9c2ea102..c0d7d93c0 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -517,7 +517,7 @@ function_body $$ = current_symtab; current_func = begin_function ($2, 0, current_symtab, 0, $-1.storage); - current_symtab = current_func->symtab; + current_symtab = current_func->locals; current_storage = sc_local; } compound_statement @@ -1249,7 +1249,7 @@ code_func $$ = current_symtab; current_func = begin_function ($0, 0, current_symtab, 0, $-1.storage); - current_symtab = current_func->symtab; + current_symtab = current_func->locals; current_storage = sc_local; } compound_statement @@ -2066,10 +2066,10 @@ methoddef current_func = begin_function (sym, nicename, ivar_scope, 1, sc_static); class_finish_ivar_scope (current_class, ivar_scope, - current_func->symtab); + current_func->locals); method->func = sym->s.func; method->def = sym->s.func->def; - current_symtab = current_func->symtab; + current_symtab = current_func->locals; current_storage = sc_local; } compound_statement diff --git a/tools/qfcc/source/qp-parse.y b/tools/qfcc/source/qp-parse.y index e7bb66647..a36f27910 100644 --- a/tools/qfcc/source/qp-parse.y +++ b/tools/qfcc/source/qp-parse.y @@ -156,7 +156,7 @@ build_dotmain (symbol_t *program) current_func = begin_function (dotmain, 0, current_symtab, 0, current_storage); - current_symtab = current_func->symtab; + current_symtab = current_func->locals; code = new_block_expr (); append_expr (code, function_expr (new_symbol_expr (program), 0)); append_expr (code, return_expr (current_func, exitcode)); @@ -180,7 +180,7 @@ program current_func = begin_function ($1, 0, current_symtab, 0, current_storage); - current_symtab = current_func->symtab; + current_symtab = current_func->locals; build_code_function ($1, 0, $4); current_symtab = st; @@ -265,14 +265,14 @@ subprogram_declaration $$ = current_storage; current_func = begin_function ($1, 0, current_symtab, 0, current_storage); - current_symtab = current_func->symtab; + current_symtab = current_func->locals; current_storage = sc_local; } declarations compound_statement ';' { append_expr ($5, new_return_expr (0)); build_code_function ($1, 0, $5); - current_symtab = current_symtab->parent; + current_symtab = current_func->parameters->parent; current_storage = $3; } | subprogram_head ASSIGNOP '#' VALUE ';' diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index bc4cb396b..51a7a4ac9 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -48,6 +48,7 @@ #include "tools/qfcc/include/class.h" #include "tools/qfcc/include/dags.h" +#include "tools/qfcc/include/defspace.h" #include "tools/qfcc/include/diagnostic.h" #include "tools/qfcc/include/dot.h" #include "tools/qfcc/include/expr.h" @@ -1011,7 +1012,7 @@ vector_call (sblock_t *sblock, expr_t *earg, expr_t *param, int ind, } static sblock_t * -expr_call (sblock_t *sblock, expr_t *call, operand_t **op) +expr_call_v6p (sblock_t *sblock, expr_t *call, operand_t **op) { expr_t *func = call->e.branch.target; expr_t *args = call->e.branch.args; @@ -1075,6 +1076,48 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) return sblock->next; } +static sblock_t * +expr_call (sblock_t *sblock, expr_t *call, operand_t **op) +{ + if (options.code.progsversion < PROG_VERSION) { + return expr_call_v6p (sblock, call, op); + } + if (!current_func->arguments) { + current_func->arguments = defspace_new (ds_virtual); + } + defspace_t *arg_space = current_func->arguments; + expr_t *func = call->e.branch.target; + expr_t *args = call->e.branch.args; + + defspace_reset (arg_space); + + args = reverse_expr_list (args); + int arg_num = 0; + for (expr_t *a = args; a; a = a->next) { + const char *arg_name = va (0, ".arg%d", arg_num++); + def_t *def = new_def (arg_name, 0, current_func->arguments, + sc_local); + type_t *arg_type = get_type (a); + int size = type_size (arg_type); + int alignment = arg_type->alignment; + if (alignment < 4) { + alignment = 4; + } + def->offset = defspace_alloc_aligned_highwater (arg_space, size, + alignment); + def->type = arg_type; + expr_t *assign = assign_expr (new_def_expr (def), a); + expr_file_line (assign, call); + sblock = statement_slist (sblock, assign); + } + statement_t *s = new_statement (st_func, "call", call); + sblock = statement_subexpr (sblock, func, &s->opa); + s->opc = short_operand (0, call); + sblock_add_statement (sblock, s); + sblock->next = new_sblock (); + return sblock->next; +} + static sblock_t * statement_branch (sblock_t *sblock, expr_t *e) { From 64da1b603a3ccc0cf53657f84b2c131f1bba52a0 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 12:05:50 +0900 Subject: [PATCH 184/360] [qfcc] Add failing test for return of postop Commit 76b3bedb72a0a1b92e658c733bf6ff079d18ce10 broke more than just the swap test, but at least I know I need to get an edge in the dag. Currently, the following code is generated: return and add are reversed. ../tools/qfcc/test/return-postop.r:8: return counter++; 0001 store.i counter, .tmp0 0002 return .tmp0 0003 add.i .tmp0, (1), counter However, I don't want to deal with it right now, so it's marked XFAIL. --- tools/qfcc/test/Makemodule.am | 14 +++++++++++++- tools/qfcc/test/return-postop.r | 22 ++++++++++++++++++++++ 2 files changed, 35 insertions(+), 1 deletion(-) create mode 100644 tools/qfcc/test/return-postop.r diff --git a/tools/qfcc/test/Makemodule.am b/tools/qfcc/test/Makemodule.am index 5d58abb99..4eb260e81 100644 --- a/tools/qfcc/test/Makemodule.am +++ b/tools/qfcc/test/Makemodule.am @@ -41,6 +41,7 @@ test_progs_dat=\ tools/qfcc/test/ptrstructcast.dat \ tools/qfcc/test/quaternion.dat \ tools/qfcc/test/return-ivar.dat \ + tools/qfcc/test/return-postop.dat \ tools/qfcc/test/sendv.dat \ tools/qfcc/test/state.dat \ tools/qfcc/test/static-init.dat \ @@ -62,7 +63,8 @@ test_progs_dat=\ tools/qfcc/test/while.dat \ tools/qfcc/test/zerolinker.dat -fail_progs_dat= +fail_progs_dat=\ + tools/qfcc/test/return-postop.dat test_build_errors=\ tools/qfcc/test/classarray.r \ @@ -483,6 +485,16 @@ tools/qfcc/test/return-ivar.run: $(qfcc_test_run_deps) include $(return_ivar_dep) # am--include-marker r_depfiles_remade += $(return_ivar_dep) +tools_qfcc_test_return_postop_dat_SOURCES=tools/qfcc/test/return-postop.r +return_postop_obj=$(tools_qfcc_test_return_postop_dat_SOURCES:.r=.o) +return_postop_dep=$(call qcautodep,$(tools_qfcc_test_return_postop_dat_SOURCES)) +tools/qfcc/test/return-postop.dat$(EXEEXT): $(return_postop_obj) $(QFCC_DEP) + $(V_QFCCLD)$(QLINK) -o $@ $(return_postop_obj) +tools/qfcc/test/return-postop.run: $(qfcc_test_run_deps) + @$(top_srcdir)/tools/qfcc/test/build-run $@ +include $(return_postop_dep) # am--include-marker +r_depfiles_remade += $(return_postop_dep) + tools_qfcc_test_sendv_dat_SOURCES=tools/qfcc/test/sendv.r sendv_obj=$(tools_qfcc_test_sendv_dat_SOURCES:.r=.o) sendv_dep=$(call qcautodep,$(tools_qfcc_test_sendv_dat_SOURCES)) diff --git a/tools/qfcc/test/return-postop.r b/tools/qfcc/test/return-postop.r new file mode 100644 index 000000000..5ec27f4a1 --- /dev/null +++ b/tools/qfcc/test/return-postop.r @@ -0,0 +1,22 @@ +#include "test-harness.h" + +int counter; + +int +function (void) +{ + return counter++; +} + +int +main (void) +{ + int ret = 0; + counter = 0; + function (); + if (counter != 1) { + printf ("counter != 1: %d\n", counter); + ret = 1; + } + return ret; +} From 33a3f925033de24cfa34018ddf30df6b6a61c2d1 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 13:09:23 +0900 Subject: [PATCH 185/360] [qfcc] Move .return handling into statements.c The means that the actual call expression is not in the statement lint of the enclosing block expression, but just its result, whether the call is void or not. This actually simplifies several things, but most importantly will make Ruamoko calls easier to implement. The test is because I had some trouble with double-calls, and is how I found the return-postop issue :P --- tools/qfcc/include/expr.h | 1 + tools/qfcc/source/expr.c | 17 ++++++++++------- tools/qfcc/source/expr_obj.c | 5 ++++- tools/qfcc/source/statements.c | 19 +++++++++++++++++++ tools/qfcc/test/Makemodule.am | 11 +++++++++++ tools/qfcc/test/twice-called.r | 28 ++++++++++++++++++++++++++++ 6 files changed, 73 insertions(+), 8 deletions(-) create mode 100644 tools/qfcc/test/twice-called.r diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 9d220b804..30b7cfd88 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -647,6 +647,7 @@ int is_math_op (int op) __attribute__((const)); int is_logic (int op) __attribute__((const)); int has_function_call (expr_t *e) __attribute__((pure)); +int is_function_call (expr_t *e) __attribute__((pure)); int is_nil (expr_t *e) __attribute__((pure)); int is_string_val (expr_t *e) __attribute__((pure)); diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index df684e288..92281b3c4 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -216,9 +216,10 @@ get_type (expr_t *e) convert_name (e); switch (e->type) { case ex_branch: - case ex_labelref: type = e->e.branch.ret_type; break; + case ex_labelref: + return &type_void; case ex_memset: return e->e.memset.type; case ex_error: @@ -504,6 +505,7 @@ copy_expr (expr_t *e) n = new_expr (); *n = *e; n->e.branch.target = copy_expr (e->e.branch.target); + n->e.branch.index = copy_expr (e->e.branch.index); n->e.branch.test = copy_expr (e->e.branch.test); n->e.branch.args = copy_expr (e->e.branch.args); return n; @@ -1658,6 +1660,12 @@ has_function_call (expr_t *e) internal_error (e, "invalid expression type"); } +int +is_function_call (expr_t *e) +{ + return e->type == ex_branch && e->e.branch.type == pr_branch_call; +} + expr_t * asx_expr (int op, expr_t *e1, expr_t *e2) { @@ -2116,12 +2124,7 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) append_expr (call, e); } e = expr_file_line (call_expr (fexpr, args, ftype->t.func.type), fexpr); - append_expr (call, e); - if (!is_void(ftype->t.func.type)) { - call->e.block.result = new_ret_expr (ftype->t.func.type); - } else if (options.traditional) { - call->e.block.result = new_ret_expr (&type_float); - } + call->e.block.result = e; return call; } diff --git a/tools/qfcc/source/expr_obj.c b/tools/qfcc/source/expr_obj.c index 33eadb742..0e8a8d53e 100644 --- a/tools/qfcc/source/expr_obj.c +++ b/tools/qfcc/source/expr_obj.c @@ -248,6 +248,9 @@ message_expr (expr_t *receiver, keywordarg_t *message) if (call->type == ex_error) return receiver; - call->e.block.result = new_ret_expr (return_type); + if (!is_function_call (call->e.block.result)) { + internal_error (call, "unexpected block result type"); + } + call->e.block.result->e.branch.ret_type = return_type; return call; } diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 51a7a4ac9..bfba55950 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1071,6 +1071,9 @@ expr_call_v6p (sblock_t *sblock, expr_t *call, operand_t **op) sblock = statement_subexpr (sblock, func, &s->opa); s->opb = arguments[0]; s->opc = arguments[1]; + if (op) { + *op = return_operand (call->e.branch.ret_type, call); + } sblock_add_statement (sblock, s); sblock->next = new_sblock (); return sblock->next; @@ -1118,6 +1121,16 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) return sblock->next; } +static sblock_t * +expr_branch (sblock_t *sblock, expr_t *e, operand_t **op) +{ + if (e->e.branch.type != pr_branch_call) { + internal_error (e, "unexpected branch type in expression: %d", + e->e.branch.type); + } + return expr_call (sblock, e, op); +} + static sblock_t * statement_branch (sblock_t *sblock, expr_t *e) { @@ -1618,6 +1631,7 @@ statement_subexpr (sblock_t *sblock, expr_t *e, operand_t **op) [ex_alias] = expr_alias, [ex_address] = expr_address, [ex_assign] = expr_assign, + [ex_branch] = expr_branch, }; if (!e) { *op = 0; @@ -1804,6 +1818,11 @@ statement_block (sblock_t *sblock, expr_t *e) sblock = sblock->next; } sblock = statement_slist (sblock, e->e.block.head); + if (e->e.block.is_call) { + // for a fuction call, the call expresion is in only the result, not + // the actual block + sblock = statement_slist (sblock, e->e.block.result); + } return sblock; } diff --git a/tools/qfcc/test/Makemodule.am b/tools/qfcc/test/Makemodule.am index 4eb260e81..1f310048a 100644 --- a/tools/qfcc/test/Makemodule.am +++ b/tools/qfcc/test/Makemodule.am @@ -53,6 +53,7 @@ test_progs_dat=\ tools/qfcc/test/structstruct.dat \ tools/qfcc/test/swap.dat \ tools/qfcc/test/triangle.dat \ + tools/qfcc/test/twice-called.dat \ tools/qfcc/test/typedef.dat \ tools/qfcc/test/typelinker.dat \ tools/qfcc/test/unaryminus.dat \ @@ -605,6 +606,16 @@ tools/qfcc/test/triangle.run: $(qfcc_test_run_deps) include $(triangle_dep) # am--include-marker r_depfiles_remade += $(triangle_dep) +tools_qfcc_test_twice_called_dat_SOURCES=tools/qfcc/test/twice-called.r +twice_called_obj=$(tools_qfcc_test_twice_called_dat_SOURCES:.r=.o) +twice_called_dep=$(call qcautodep,$(tools_qfcc_test_twice_called_dat_SOURCES)) +tools/qfcc/test/twice-called.dat$(EXEEXT): $(twice_called_obj) $(QFCC_DEP) + $(V_QFCCLD)$(QLINK) -o $@ $(twice_called_obj) +tools/qfcc/test/twice-called.run: $(qfcc_test_run_deps) + @$(top_srcdir)/tools/qfcc/test/build-run $@ 100000 100000 1.00005 50002.4961 +include $(twice_called_dep) # am--include-marker +r_depfiles_remade += $(twice_called_dep) + tools_qfcc_test_typedef_dat_SOURCES=tools/qfcc/test/typedef.r typedef_obj=$(tools_qfcc_test_typedef_dat_SOURCES:.r=.o) typedef_dep=$(call qcautodep,$(tools_qfcc_test_typedef_dat_SOURCES)) diff --git a/tools/qfcc/test/twice-called.r b/tools/qfcc/test/twice-called.r new file mode 100644 index 000000000..9542af0f6 --- /dev/null +++ b/tools/qfcc/test/twice-called.r @@ -0,0 +1,28 @@ +#include "test-harness.h" + +int counter; + +int +function (void) +{ + return ++counter; +} + +int +main (void) +{ + int ret = 0; + counter = 0; + //function (); + //if (counter != 1) { + //printf ("discarded return not called only once\n"); + // ret = 1; + //} + counter = 0; + printf ("function: %d\n", function ()); + if (counter != 1) { + //printf ("used return not called only once\n"); + ret = 1; + } + return ret; +} From c53127707b52a7575d908bf10bfb8d7f1813e6a3 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 13:50:21 +0900 Subject: [PATCH 186/360] [qfcc] Set the return of Ruamoko calls Of course, I had the width of opc wrong :P. But with this, it seems that unoptimized calls should work once I get the stack frame working. --- libs/gamecode/opcodes.py | 2 +- tools/qfcc/source/statements.c | 9 ++++++++- 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 37ca5c2e2..ac5aa5e51 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -114,7 +114,7 @@ call_formats = { "mnemonic": "call", "opname": "call", "format": "{call_fmt[mm]}", - "widths": "{call_widths[mm]}, 0", + "widths": "{call_widths[mm]}, -1", "types": "{call_types[mm]}, ev_void", "args": { "op_mode": ".BCD", diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index bfba55950..fc5823395 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1115,7 +1115,14 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) } statement_t *s = new_statement (st_func, "call", call); sblock = statement_subexpr (sblock, func, &s->opa); - s->opc = short_operand (0, call); + if (!op) { + s->opc = short_operand (0, call); + } else { + if (!*op) { + *op = temp_operand (call->e.branch.ret_type, call); + } + s->opc = *op; + } sblock_add_statement (sblock, s); sblock->next = new_sblock (); return sblock->next; From 616a52efb570691ed835c25bc4e276238943043f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 16:19:04 +0900 Subject: [PATCH 187/360] [qfcc] Implement flow analysis for Ruamoko calls Thanks to the use/def/kill lists attached to statements for pseudo-ops, it turned out to be a lot easier to implement flow analysis (and thus dags processing) than I expected. I suspect I should go back and make the old call code use them too, and probably several other places, as that will greatly simplify the edge setting. --- tools/qfcc/include/statements.h | 6 +++--- tools/qfcc/source/dags.c | 14 +++++++++++--- tools/qfcc/source/flow.c | 7 ++++++- tools/qfcc/source/statements.c | 15 +++++++++++++++ 4 files changed, 35 insertions(+), 7 deletions(-) diff --git a/tools/qfcc/include/statements.h b/tools/qfcc/include/statements.h index 622d7c377..3bee3de33 100644 --- a/tools/qfcc/include/statements.h +++ b/tools/qfcc/include/statements.h @@ -113,9 +113,9 @@ typedef struct statement_s { operand_t *opc; struct expr_s *expr; ///< source expression for this statement int number; ///< number of this statement in function - operand_t *use; ///< list of pseudo operands used - operand_t *def; ///< list of pseudo operands defined - operand_t *kill; ///< list of pseudo operands killed + operand_t *use; ///< list of auxiliary operands used + operand_t *def; ///< list of auxiliary operands defined + operand_t *kill; ///< list of auxiliary operands killed } statement_t; typedef struct sblock_s { diff --git a/tools/qfcc/source/dags.c b/tools/qfcc/source/dags.c index d4a7b4fbe..a128422cc 100644 --- a/tools/qfcc/source/dags.c +++ b/tools/qfcc/source/dags.c @@ -406,7 +406,7 @@ dag_find_node (def_t *def, void *_daglabel) } static void -dagnode_set_edges (dag_t *dag, dagnode_t *n) +dagnode_set_edges (dag_t *dag, dagnode_t *n, statement_t *s) { int i; @@ -447,13 +447,21 @@ dagnode_set_edges (dag_t *dag, dagnode_t *n) set_add (n->edges, child->number); } } + for (operand_t *use = s->use; use; use = use->next) { + if (use->op_type == op_pseudo) { + continue; + } + daglabel_t *label = operand_label (dag, use); + label->live = 1; + set_add (n->edges, label->dagnode->number); + } if (n->type == st_func) { const char *num_params = 0; int first_param = 0; flowvar_t **flowvars = dag->flownode->graph->func->vars; if (!strcmp (n->label->opcode, "call")) { - internal_error (0, "not implemented"); + // nothing to do } else if (!strncmp (n->label->opcode, "rcall", 5)) { num_params = n->label->opcode + 6; first_param = 2; @@ -864,7 +872,7 @@ dag_create (flownode_t *flownode) n->type = s->type; n->label = op; dagnode_add_children (dag, n, operands, children); - dagnode_set_edges (dag, n); + dagnode_set_edges (dag, n, s); dagnode_set_reachable (dag, n); } } diff --git a/tools/qfcc/source/flow.c b/tools/qfcc/source/flow.c index 8bcd4bbeb..8db692667 100644 --- a/tools/qfcc/source/flow.c +++ b/tools/qfcc/source/flow.c @@ -1278,7 +1278,12 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, } } if (strcmp (s->opcode, "call") == 0) { - internal_error (s->expr, "not implemented"); + // call uses opc to specify the destination of the return value + // parameter usage is taken care of by the statement's use + // list + flow_add_op_var (def, s->opc, 0); + // don't want old argument processing + calln = -1; } else if (strncmp (s->opcode, "call", 4) == 0) { start = 0; calln = s->opcode[5] - '0'; diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index fc5823395..b47dc4a50 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1091,6 +1091,8 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) defspace_t *arg_space = current_func->arguments; expr_t *func = call->e.branch.target; expr_t *args = call->e.branch.args; + operand_t *use = 0; + operand_t *kill = 0; defspace_reset (arg_space); @@ -1112,6 +1114,17 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) expr_t *assign = assign_expr (new_def_expr (def), a); expr_file_line (assign, call); sblock = statement_slist (sblock, assign); + + // The call both uses and kills the arguments: use is obvious, but kill + // is because the callee has direct access to them and might modify + // them + // need two ops for the one def because there's two lists + operand_t *u = def_operand (def, arg_type, call); + operand_t *k = def_operand (def, arg_type, call); + u->next = use; + use = u; + k->next = kill; + kill = k; } statement_t *s = new_statement (st_func, "call", call); sblock = statement_subexpr (sblock, func, &s->opa); @@ -1123,6 +1136,8 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) } s->opc = *op; } + s->use = use; + s->kill = kill; sblock_add_statement (sblock, s); sblock->next = new_sblock (); return sblock->next; From 3df46d197fa33907b5046db0034093178ec3450b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 18:44:51 +0900 Subject: [PATCH 188/360] [gamecode] Add instructions for stack adjust, nop, and ldconst ldconst isn't implemented yet but the plan is to load various constants (eg, 0, 1, 2, pi, e, ...). Stack adjust is useful for adding an offset to the stack pointer without having to worry about finding it (and it checks for alignment). nop is just that :) --- libs/gamecode/opcodes.py | 30 ++++++++++++++++++++++++++++++ libs/gamecode/pr_exec.c | 12 ++++++++++++ 2 files changed, 42 insertions(+) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index ac5aa5e51..d6cb80f6f 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -5,6 +5,9 @@ bitmap_txt = """ 0 0011 mmss pop 0 1ccc ttss compare 0 0000 00nn +0 0000 0000 noop +0 0000 0001 adjstk +0 0000 0010 constant 0 1011 nnnn 0 1111 nnnn @@ -75,6 +78,14 @@ etype_tt = ["ev_int", "ev_float", "ev_long", "ev_double"] unsigned_t = ["ev_uint", "ev_ulong"] float_t = ["ev_float", "ev_double"] +adjstk_formats = { + "opcode": "OP_ADJSTK", + "mnemonic": "adjstk", + "opname": "adjstk", + "format": "%sa, %sb", + "widths": "0, 0, 0", + "types": "ev_short, ev_short, ev_invalid", +} bitops_formats = { "opcode": "OP_{op_bit[oo].upper()}_{bit_type[t]}_{ss+1}", "mnemonic": "{op_bit[oo]}", @@ -157,6 +168,14 @@ compare2_formats = { "cmp_types": unsigned_t, }, } +constant_formats = { + "opcode": "OP_LDCONST", + "mnemonic": "ldconst", + "opname": "ldconst", + "format": "%sa, %sb, %gc", + "widths": "0, 0, -1", + "types": "ev_short, ev_short, ev_void", +} convert_formats = { "opcode": "OP_CONV", "mnemonic": "conv", @@ -268,6 +287,14 @@ move_formats = { ], }, } +noop_formats = { + "opcode": "OP_NOP", + "mnemonic": "nop", + "opname": "nop", + "format": "there were plums...", + "widths": "0, 0, 0", + "types": "ev_invalid, ev_invalid, ev_invalid", +} push_formats = { "opcode": "OP_PUSH_{op_mode[mm]}_{ss+1}", "mnemonic": "push", @@ -473,11 +500,13 @@ with_formats = { } group_map = { + "adjstk": adjstk_formats, "bitops": bitops_formats, "branch": branch_formats, "call": call_formats, "compare": compare_formats, "compare2": compare2_formats, + "constant": constant_formats, "convert": convert_formats, "hops": hops_formats, "jump": jump_formats, @@ -486,6 +515,7 @@ group_map = { "mathops": mathops_formats, "memset": memset_formats, "move": move_formats, + "noop": noop_formats, "push": push_formats, "pushregs": pushregs_formats, "pop": pop_formats, diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 15885244c..a7581cbc4 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -2766,6 +2766,18 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) pr_opcode_e st_op = st->op & OP_MASK; switch (st_op) { // 0 0000 + case OP_NOP: + break; + case OP_ADJSTK: + if (st->a || (st->b & 3)) { + PR_RunError (pr, "invalid stack adjustment: %d, %d", + st->a, (short) st->b); + } + *pr->globals.stack += (short) st->b; + break; + case OP_LDCONST: + PR_RunError (pr, "OP_LDCONST not implemented"); + break; case OP_LOAD_B_1: case OP_LOAD_C_1: case OP_LOAD_D_1: From 79bd4dd7245a491d58c576db2f67b006d4925ea5 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 18:47:12 +0900 Subject: [PATCH 189/360] [qfcc] Set up the function stack frame Still need to get the base register index into the instructions, but I think this is it for basic code generation. I should be able to start testing Ruamoko properly fairly soon :) --- tools/qfcc/include/expr.h | 15 ++++++++++++ tools/qfcc/include/expr_names.h | 2 ++ tools/qfcc/source/expr.c | 42 ++++++++++++++++++++++++++++++++- tools/qfcc/source/expr_assign.c | 2 ++ tools/qfcc/source/function.c | 23 ++++++++++++++++-- tools/qfcc/source/statements.c | 24 +++++++++++++++++++ 6 files changed, 105 insertions(+), 3 deletions(-) diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 30b7cfd88..aeb4e86ff 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -238,6 +238,17 @@ typedef struct { struct expr_s *ret_val; } ex_return_t; +typedef struct { + short mode; ///< currently must be 0 + short offset; ///< amount by which stack will be adjusted +} ex_adjstk_t; + +typedef struct { + short mode; ///< currently must be 0 + short reg; ///< base register to load + struct expr_s *with; ///< value to load +} ex_with_t; + #define POINTER_VAL(p) (((p).def ? (p).def->offset : 0) + (p).val) typedef struct expr_s { @@ -269,6 +280,8 @@ typedef struct expr_s { ex_assign_t assign; ///< assignment expr params ex_branch_t branch; ///< branch expr params ex_return_t retrn; ///< return expr params + ex_adjstk_t adjstk; ///< stack adjust param + ex_with_t with; ///< with expr param struct type_s *nil; ///< type for nil if known } e; } expr_t; @@ -688,6 +701,8 @@ expr_t *new_address_expr (struct type_s *lvtype, expr_t *lvalue, expr_t *offset); expr_t *new_assign_expr (expr_t *dst, expr_t *src); expr_t *new_return_expr (expr_t *ret_val); +expr_t *new_adjstk_expr (int mode, int offset); +expr_t *new_with_expr (int mode, int reg, expr_t *val); /** Create an expression of the correct type that references the specified parameter slot. diff --git a/tools/qfcc/include/expr_names.h b/tools/qfcc/include/expr_names.h index 08285c94a..5af4e739b 100644 --- a/tools/qfcc/include/expr_names.h +++ b/tools/qfcc/include/expr_names.h @@ -59,5 +59,7 @@ EX_EXPR(address) ///< address of an lvalue expression (::ex_address_t) EX_EXPR(assign) ///< assignment of src expr to dst expr (::ex_assing_t) EX_EXPR(branch) ///< branch expression (::ex_branch_t) EX_EXPR(return) ///< return expression (::ex_return_t) +EX_EXPR(adjstk) ///< stack adjust expression (::ex_adjstk_t) +EX_EXPR(with) ///< with expression (::ex_with_t) ///@} diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 92281b3c4..9395d699c 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -219,6 +219,8 @@ get_type (expr_t *e) type = e->e.branch.ret_type; break; case ex_labelref: + case ex_adjstk: + case ex_with: return &type_void; case ex_memset: return e->e.memset.type; @@ -512,7 +514,16 @@ copy_expr (expr_t *e) case ex_return: n = new_expr (); *n = *e; - n->e.retrn.ret_val = copy_expr (n->e.retrn.ret_val); + n->e.retrn.ret_val = copy_expr (e->e.retrn.ret_val); + return n; + case ex_adjstk: + n = new_expr (); + *n = *e; + return n; + case ex_with: + n = new_expr (); + *n = *e; + n->e.with.with = copy_expr (e->e.with.with); return n; case ex_count: break; @@ -1344,6 +1355,27 @@ new_return_expr (expr_t *ret_val) return retrn; } +expr_t * +new_adjstk_expr (int mode, int offset) +{ + expr_t *adj = new_expr (); + adj->type = ex_adjstk; + adj->e.adjstk.mode = mode; + adj->e.adjstk.offset = offset; + return adj; +} + +expr_t * +new_with_expr (int mode, int reg, expr_t *val) +{ + expr_t *with = new_expr (); + with->type = ex_with; + with->e.with.mode = mode; + with->e.with.reg = reg; + with->e.with.with = val; + return with; +} + static expr_t * param_expr (const char *name, type_t *type) { @@ -1653,6 +1685,8 @@ has_function_call (expr_t *e) case ex_value: case ex_compound: case ex_memset: + case ex_adjstk: + case ex_with: return 0; case ex_count: break; @@ -1745,6 +1779,8 @@ unary_expr (int op, expr_t *e) case ex_memset: case ex_selector: case ex_return: + case ex_adjstk: + case ex_with: internal_error (e, "unexpected expression type"); case ex_uexpr: if (e->e.expr.op == '-') { @@ -1847,6 +1883,8 @@ unary_expr (int op, expr_t *e) case ex_memset: case ex_selector: case ex_return: + case ex_adjstk: + case ex_with: internal_error (e, "unexpected expression type"); case ex_bool: return new_bool_expr (e->e.bool.false_list, @@ -1927,6 +1965,8 @@ unary_expr (int op, expr_t *e) case ex_memset: case ex_selector: case ex_return: + case ex_adjstk: + case ex_with: internal_error (e, "unexpected expression type"); case ex_uexpr: if (e->e.expr.op == '~') diff --git a/tools/qfcc/source/expr_assign.c b/tools/qfcc/source/expr_assign.c index 4eec4916a..0926931fb 100644 --- a/tools/qfcc/source/expr_assign.c +++ b/tools/qfcc/source/expr_assign.c @@ -138,6 +138,8 @@ is_lvalue (const expr_t *expr) case ex_error: case ex_selector: case ex_return: + case ex_adjstk: + case ex_with: break; case ex_count: internal_error (expr, "invalid expression"); diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index bfc1da059..b4cf2b2c6 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -673,9 +673,21 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements) state_expr->next = statements; statements = state_expr; } - if (options.code.progsversion == PROG_VERSION) { - } function_t *func = fsym->s.func; + if (options.code.progsversion == PROG_VERSION) { + expr_t *e; + e = new_with_expr (2, 1, new_short_expr (0)); + e->next = statements; + e->file = func->def->file; + e->line = func->def->line; + statements = e; + + e = new_adjstk_expr (0, 0); + e->next = statements; + e->file = func->def->file; + e->line = func->def->line; + statements = e; + } emit_function (func, statements); if (options.code.progsversion < PROG_VERSION) { // stitch parameter and locals data together with parameters coming @@ -699,6 +711,13 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements) merge_spaces (space, func->locals->space, 4); func->locals->space = space; + // allocate 0 words to force alignment + defspace_alloc_aligned_highwater (space, 0, 4); + + dstatement_t *st = &pr.code->code[func->code]; + if (st->op == OP_ADJSTK) { + st->b = -space->size; + } merge_spaces (space, func->parameters->space, 4); func->parameters->space = space; } diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index b47dc4a50..1168c3fcf 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1235,6 +1235,28 @@ statement_return (sblock_t *sblock, expr_t *e) return sblock; } +static sblock_t * +statement_adjstk (sblock_t *sblock, expr_t *e) +{ + statement_t *s = new_statement (st_func, "adjstk", e); + s->opa = short_operand (e->e.adjstk.mode, e); + s->opb = short_operand (e->e.adjstk.offset, e); + + sblock_add_statement (sblock, s); + return sblock; +} + +static sblock_t * +statement_with (sblock_t *sblock, expr_t *e) +{ + statement_t *s = new_statement (st_func, "with", e); + s->opa = short_operand (e->e.with.mode, e); + s->opc = short_operand (e->e.with.reg, e); + sblock = statement_subexpr (sblock, e->e.with.with, &s->opb); + sblock_add_statement (sblock, s); + return sblock; +} + static statement_t * lea_statement (operand_t *pointer, operand_t *offset, expr_t *e) { @@ -1930,6 +1952,8 @@ statement_slist (sblock_t *sblock, expr_t *e) [ex_assign] = statement_assign, [ex_branch] = statement_branch, [ex_return] = statement_return, + [ex_adjstk] = statement_adjstk, + [ex_with] = statement_with, }; for (/**/; e; e = e->next) { From 9199a0ee54c951368f8b89289ebb93222de14bc6 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 20:31:49 +0900 Subject: [PATCH 190/360] [gamecode] Don't check v6p progs for Ruamoko progs It doesn't end well. For now, the Ruamoko check is just a stub, but I do plan on doing similar checks. --- include/QF/progs.h | 1 + libs/gamecode/pr_opcode.c | 9 +++++++++ libs/gamecode/pr_v6p_opcode.c | 2 +- 3 files changed, 11 insertions(+), 1 deletion(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 02cbb0229..57e88fccd 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -264,6 +264,7 @@ int PR_RunPostLoadFuncs (progs_t *pr); \todo should this be elsewhere? */ int PR_Check_Opcodes (progs_t *pr); +int PR_Check_v6p_Opcodes (progs_t *pr); void PR_BoundsCheckSize (progs_t *pr, pr_ptr_t addr, unsigned size); void PR_BoundsCheck (progs_t *pr, int addr, etype_t type); diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index 799066c7c..289f06a1f 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -61,3 +61,12 @@ PR_Opcode (pr_ushort_t opcode) opcode &= OP_MASK; return &pr_opcodes[opcode]; } + +int +PR_Check_Opcodes (progs_t *pr) +{ + if (pr->progs->version < PROG_VERSION) { + return PR_Check_v6p_Opcodes (pr); + } + return 1; +} diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index e9b3a0b7a..2e9514a93 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -1591,7 +1591,7 @@ error: } int -PR_Check_Opcodes (progs_t *pr) +PR_Check_v6p_Opcodes (progs_t *pr) { const v6p_opcode_t *op; dstatement_t *st; From 7a5ee6a55a17f90e801a50487db43acf45143ac5 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 20:33:15 +0900 Subject: [PATCH 191/360] [gamecode] Initialize .stack if it's available And implement bounds checks for adjstk. --- libs/gamecode/pr_exec.c | 21 ++++++++++++++++----- libs/gamecode/pr_load.c | 3 +++ 2 files changed, 19 insertions(+), 5 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index a7581cbc4..7802e5e0f 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1897,6 +1897,21 @@ pr_stack_pop (progs_t *pr) return stk; } +static void +pr_stack_adjust (progs_t *pr, int mode, int offset) +{ + // keep the stack 16-byte aligned + if (mode || (offset & 3)) { + PR_RunError (pr, "invalid stack adjustment: %d, %d", mode, offset); + } + + pr_ptr_t stack = *pr->globals.stack; + if (pr_boundscheck->int_val) { + check_stack_pointer (pr, stack + offset, 0); + } + *pr->globals.stack = stack + offset; +} + static void pr_with (progs_t *pr, const dstatement_t *st) { @@ -2769,11 +2784,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_NOP: break; case OP_ADJSTK: - if (st->a || (st->b & 3)) { - PR_RunError (pr, "invalid stack adjustment: %d, %d", - st->a, (short) st->b); - } - *pr->globals.stack += (short) st->b; + pr_stack_adjust (pr, st->a, (short) st->b); break; case OP_LDCONST: PR_RunError (pr, "OP_LDCONST not implemented"); diff --git a/libs/gamecode/pr_load.c b/libs/gamecode/pr_load.c index 9770bc786..e8538d5bd 100644 --- a/libs/gamecode/pr_load.c +++ b/libs/gamecode/pr_load.c @@ -226,6 +226,9 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) pr->stack_bottom = pr->stack - pr->pr_globals; pr->globals_size = (pr_type_t *) ((byte *) pr->stack + pr->stack_size) - pr->pr_globals; + if (pr->globals.stack && pr->stack_bottom) { + *pr->globals.stack = pr->globals_size; + } if (pr->zone) { PR_Zone_Init (pr); From 0a5101f88c34bcb723db26e1bb125d6101de4592 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 20:34:43 +0900 Subject: [PATCH 192/360] [qfcc] Specify base register index for local defs While all base registers can be used for any purpose at any time (this is why the with instruction has hard-absolute modes: you can never get permanently lost), qfcc currently uses the convention of register 0 for globals and register 1 for stack locals (params, locals, function args). The register used to access a def is stored in the def and that is used to set the register bits in the instruction opcode. The def code actually doesn't know anything about any conventions: it assumes all defs are global for non-temp defs (the function code updates the defs before emitting code) and the current function provides the register to use for any temp defs allocated while emitting code. Seems to work well, but debug is utterly messed up (not surprised, that will be tricky). --- tools/qfcc/include/def.h | 1 + tools/qfcc/include/function.h | 1 + tools/qfcc/source/def.c | 1 + tools/qfcc/source/emit.c | 16 +++++++++++++--- tools/qfcc/source/function.c | 18 +++++++++++++++++- 5 files changed, 33 insertions(+), 4 deletions(-) diff --git a/tools/qfcc/include/def.h b/tools/qfcc/include/def.h index f49dd2f8e..1477cc7e3 100644 --- a/tools/qfcc/include/def.h +++ b/tools/qfcc/include/def.h @@ -60,6 +60,7 @@ typedef struct def_s { const char *name; ///< the def's name struct defspace_s *space; ///< defspace to which this def belongs int offset; ///< address of this def in its defspace + int reg; ///< base register index to access def /** \name Def aliasing. Aliasing a def provides a different view of the def providing access diff --git a/tools/qfcc/include/function.h b/tools/qfcc/include/function.h index 3b04bb9e5..cceef9341 100644 --- a/tools/qfcc/include/function.h +++ b/tools/qfcc/include/function.h @@ -69,6 +69,7 @@ typedef struct function_s { pr_string_t s_file; ///< source file with definition pr_string_t s_name; ///< name of function in output const struct type_s *type; ///< function's type without aliases + int temp_reg; ///< base register to use for temp defs int temp_num; ///< number for next temp var struct def_s *temp_defs[4]; ///< freed temp vars (by size) struct def_s *def; ///< output def holding function number diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c index 5f6947c37..2cc92d4aa 100644 --- a/tools/qfcc/source/def.c +++ b/tools/qfcc/source/def.c @@ -230,6 +230,7 @@ temp_def (type_t *type) temp->line = pr.source_line; set_storage_bits (temp, sc_local); temp->space = space; + temp->reg = current_func->temp_reg; return temp; } diff --git a/tools/qfcc/source/emit.c b/tools/qfcc/source/emit.c index 3ee80df7f..60dd095d2 100644 --- a/tools/qfcc/source/emit.c +++ b/tools/qfcc/source/emit.c @@ -228,10 +228,20 @@ emit_statement (statement_t *statement) } } s = codespace_newstatement (pr.code); + memset (s, 0, sizeof (*s)); s->op = opcode_get (inst); - s->a = def_a ? def_a->offset : 0; - s->b = def_b ? def_b->offset : 0; - s->c = def_c ? def_c->offset : 0; + if (def_a) { + s->a = def_a->offset; + s->op |= ((def_a->reg) << OP_A_SHIFT) & OP_A_BASE; + } + if (def_b) { + s->b = def_b->offset; + s->op |= ((def_b->reg) << OP_B_SHIFT) & OP_B_BASE; + } + if (def_c) { + s->c = def_c->offset; + s->op |= ((def_c->reg) << OP_C_SHIFT) & OP_C_BASE; + } if (options.verbosity >= 2) { opcode_print_statement (pr.code->size - 1, s); diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index b4cf2b2c6..a4d785d6d 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -71,6 +71,10 @@ static function_t *functions_freelist; static hashtab_t *overloaded_functions; static hashtab_t *function_map; +// standardized base register to use for all locals (arguments, local defs, +// params) +#define LOCALS_REG 1 + static const char * ol_func_get_key (const void *_f, void *unused) { @@ -676,7 +680,7 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements) function_t *func = fsym->s.func; if (options.code.progsversion == PROG_VERSION) { expr_t *e; - e = new_with_expr (2, 1, new_short_expr (0)); + e = new_with_expr (2, LOCALS_REG, new_short_expr (0)); e->next = statements; e->file = func->def->file; e->line = func->def->line; @@ -687,6 +691,18 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements) e->file = func->def->file; e->line = func->def->line; statements = e; + + func->temp_reg = LOCALS_REG; + for (def_t *def = func->locals->space->defs; def; def = def->next) { + if (def->local || def->param) { + def->reg = LOCALS_REG; + } + } + for (def_t *def = func->parameters->space->defs; def; def = def->next) { + if (def->local || def->param) { + def->reg = LOCALS_REG; + } + } } emit_function (func, statements); if (options.code.progsversion < PROG_VERSION) { From 2a89a678ec7d957dd9a8610e677d1f9984723803 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 20:46:26 +0900 Subject: [PATCH 193/360] [qfcc] Don't allocate local defs for Ruamoko progs They don't need the defs thanks to the stack. --- tools/qfcc/source/obj_file.c | 32 ++++++++++++++++++-------------- 1 file changed, 18 insertions(+), 14 deletions(-) diff --git a/tools/qfcc/source/obj_file.c b/tools/qfcc/source/obj_file.c index 17ba70080..6a53b32ab 100644 --- a/tools/qfcc/source/obj_file.c +++ b/tools/qfcc/source/obj_file.c @@ -982,14 +982,16 @@ qfo_to_progs (qfo_t *in_qfo, int *size) progs->numglobals = qfo->spaces[qfo_near_data_space].data_size; progs->numglobals = align_globals_size (progs->numglobals); locals_start = progs->numglobals; - for (i = qfo_num_spaces; i < qfo->num_spaces; i++) { - if (options.code.local_merging) { - if (locals_size < qfo->spaces[i].data_size) { - locals_size = qfo->spaces[i].data_size; - big_locals = i; + if (options.code.progsversion < PROG_VERSION) { + for (i = qfo_num_spaces; i < qfo->num_spaces; i++) { + if (options.code.local_merging) { + if (locals_size < qfo->spaces[i].data_size) { + locals_size = qfo->spaces[i].data_size; + big_locals = i; + } + } else { + locals_size += align_globals_size (qfo->spaces[i].data_size); } - } else { - locals_size += align_globals_size (qfo->spaces[i].data_size); } } progs->numglobals += locals_size; @@ -1081,13 +1083,15 @@ qfo_to_progs (qfo_t *in_qfo, int *size) qfo_mspace_t *space = qfo->spaces + qf->locals_space; df->first_statement = qf->code; - df->parm_start = locals_start; - df->locals = space->data_size; - // finalize the offsets of the local defs - for (j = 0; j < space->num_defs; j++) - space->defs[j].offset += locals_start; - if (!options.code.local_merging) - locals_start += align_globals_size (df->locals); + if (options.code.progsversion < PROG_VERSION) { + df->parm_start = locals_start; + df->locals = space->data_size; + // finalize the offsets of the local defs + for (j = 0; j < space->num_defs; j++) + space->defs[j].offset += locals_start; + if (!options.code.local_merging) + locals_start += align_globals_size (df->locals); + } df->profile = 0; df->name = qf->name; df->file = qf->file; From e6fbe9fdbc9b4ade1ce1fd4a4b2f14fd6fbd2920 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 21 Jan 2022 20:47:35 +0900 Subject: [PATCH 194/360] [qfcc] Create .stack for Ruamoko progs It's rather necessary :) --- tools/qfcc/source/qfcc.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tools/qfcc/source/qfcc.c b/tools/qfcc/source/qfcc.c index 25c1a89c6..134890dea 100644 --- a/tools/qfcc/source/qfcc.c +++ b/tools/qfcc/source/qfcc.c @@ -447,6 +447,10 @@ finish_link (void) ¶m_alignment); linker_add_def (".xdefs", &type_xdefs, flags, 0); } + if (options.code.progsversion == PROG_VERSION) { + int stk = (QFOD_GLOBAL | QFOD_INITIALIZED | QFOD_NOSAVE); + linker_add_def (".stack", &type_uint, stk, 0); + } if (options.code.debug) { pr_int_t str; From 06b1ea6837a82192d61b283744f1d003e82fc367 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 22 Jan 2022 10:57:26 +0900 Subject: [PATCH 195/360] [gamecode] Tweak some docs and macro names And fix an incorrect definition for RETURN_QUAT. Prefixed MAX_STACK_DEPTH and LOCALSTACK_SIZE (and LOCALSTACK_SIZE got an extra _). The rest is just edits to documentation comments. --- include/QF/progs.h | 15 +++++++-------- libs/gamecode/pr_exec.c | 4 ++-- 2 files changed, 9 insertions(+), 10 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 57e88fccd..0709e4891 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -197,7 +197,7 @@ typedef int pr_load_func_t (progs_t *pr); /** Initialize a ::progs_t VM struct from an already open file. \param pr pointer to ::progs_t VM struct - \param file handle of file to read progs data from + \param file handle of file from which to read progs data \param size bytes of \p file to read \note \e All runtime strings (permanent or temporary) are allocated from @@ -981,7 +981,7 @@ void PR_Undefined (progs_t *pr, const char *type, const char *name) __attribute_ \hideinitializer */ -#define RETURN_QUAT(p,q) VectorCopy (q, R_QUAT (p)) +#define RETURN_QUAT(p,q) QuatCopy (q, R_QUAT (p)) ///@} /** \defgroup prda_entity_fields Entity Fields @@ -1504,7 +1504,6 @@ void PR_Resources_Clear (progs_t *pr); \param name The name of the resource. Used for retrieving the resource. \param data The resource data. - callback. \param clear Callback for performing any necessary cleanup. Called by PR_Resources_Clear(). The parameters are the current VM (\p pr) and \p data. @@ -1796,8 +1795,8 @@ extern const char *pr_gametype; //============================================================================ -#define MAX_STACK_DEPTH 64 -#define LOCALSTACK_SIZE 4096 +#define PR_MAX_STACK_DEPTH 64 +#define PR_LOCAL_STACK_SIZE 4096 #define PR_RS_SLOTS 16 #define PR_BASE_IND(o, b) (((o) & OP_##b##_BASE) >> OP_##b##_SHIFT) #define PR_BASE(p, s, b) (p->pr_bases[PR_BASE_IND(s->op, b)]) @@ -1927,7 +1926,7 @@ struct progs_s { bfunction_t *pr_xfunction; int pr_xstatement; - prstack_t pr_stack[MAX_STACK_DEPTH]; + prstack_t pr_stack[PR_MAX_STACK_DEPTH]; int pr_depth; /// \name progs visible stack @@ -1943,7 +1942,7 @@ struct progs_s { int stack_size; ///< set by user ///@} - int localstack[LOCALSTACK_SIZE]; + int localstack[PR_LOCAL_STACK_SIZE]; int localstack_used; ///@} @@ -1974,7 +1973,7 @@ struct progs_s { double *dtime; ///< required for OP_STATE d float *ftime; ///< required for OP_STATE f pr_uint_t *self; ///< required for OP_STATE - pr_ptr_t *stack; ///< required for OP_(PUSH|POP)* + pr_ptr_t *stack; ///< required for OP_(PUSH|POP)* } globals; struct { pr_int_t nextthink; ///< required for OP_STATE diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 7802e5e0f..9d8469185 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -137,7 +137,7 @@ PR_PushFrame (progs_t *pr) { prstack_t *frame; - if (pr->pr_depth == MAX_STACK_DEPTH) + if (pr->pr_depth == PR_MAX_STACK_DEPTH) PR_RunError (pr, "stack overflow"); frame = pr->pr_stack + pr->pr_depth++; @@ -272,7 +272,7 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) pr->pr_xstatement = f->first_statement - 1; // offset the st++ // save off any locals that the new function steps on - if (pr->localstack_used + f->locals > LOCALSTACK_SIZE) + if (pr->localstack_used + f->locals > PR_LOCAL_STACK_SIZE) PR_RunError (pr, "PR_EnterFunction: locals stack overflow"); memcpy (&pr->localstack[pr->localstack_used], From 68d87de2516db00c781da0500fb13f2862f1bc38 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 22 Jan 2022 11:38:26 +0900 Subject: [PATCH 196/360] [gamecode] Clarify docs for PR_CallFunction I found the docs in PR_ExecuteProgram and PR_CallFunction to be a little confusing, so making it explicit that PR_ExecuteProgram calls PR_CallFunction and that PR_CallFunction should be called only in a builtin seemed like a good idea. --- include/QF/progs.h | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/include/QF/progs.h b/include/QF/progs.h index 0709e4891..3da8bca00 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -166,6 +166,7 @@ void PR_PopFrame (progs_t *pr); return to the caller. Nested calls are fully supported. \param pr pointer to ::progs_t VM struct \param fnum number of the function to call + \note Calls PR_CallFunction() */ void PR_ExecuteProgram (progs_t *pr, pr_func_t fnum); @@ -179,6 +180,9 @@ void PR_ExecuteProgram (progs_t *pr, pr_func_t fnum); written \return true if \p fnum was a progs function, false if \p fnum was a builtin + \note Called by PR_ExecuteProgram, so the only time this should be called + is in a builtin function that calls a progs function and returns + immediately (eg, to implement `return progsfunc();`). */ int PR_CallFunction (progs_t *pr, pr_func_t fnum, pr_type_t *return_ptr); From 9e4ecc14e95393befa21ac47a4b013a417f8fece Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 22 Jan 2022 15:31:26 +0900 Subject: [PATCH 197/360] [qfcc] Fix error in handling argc in test-harness There was an out-by-one where attempting to run a program with only one argument would result in the argument not being passed to the program (two worked). This is actually the source of the error fixed in 9347e4f9019c9ad69584a62f14c9fa4cefec293c because test-harness.c was the basis for qwaq's main.c --- tools/qfcc/test/test-harness.c | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/tools/qfcc/test/test-harness.c b/tools/qfcc/test/test-harness.c index c0aa96b10..bf51508b9 100644 --- a/tools/qfcc/test/test-harness.c +++ b/tools/qfcc/test/test-harness.c @@ -276,24 +276,29 @@ main (int argc, char **argv) if (!load_progs (name)) Sys_Error ("couldn't load %s", name); + if ((dfunc = PR_FindFunction (&test_pr, ".main")) + || (dfunc = PR_FindFunction (&test_pr, "main"))) { + main_func = dfunc - test_pr.pr_functions; + } else { + PR_Undefined (&test_pr, "function", "main"); + } + PR_PushFrame (&test_pr); - if (argc > 2) + if (argc) { pr_argc = argc; + } pr_argv = PR_Zone_Malloc (&test_pr, (pr_argc + 1) * 4); pr_argv[0] = PR_SetTempString (&test_pr, name); - for (i = 1; i < pr_argc; i++) + for (i = 1; i < pr_argc; i++) { pr_argv[i] = PR_SetTempString (&test_pr, argv[i]); + } pr_argv[i] = 0; - if ((dfunc = PR_FindFunction (&test_pr, ".main")) - || (dfunc = PR_FindFunction (&test_pr, "main"))) - main_func = dfunc - test_pr.pr_functions; - else - PR_Undefined (&test_pr, "function", "main"); PR_RESET_PARAMS (&test_pr); P_INT (&test_pr, 0) = pr_argc; P_POINTER (&test_pr, 1) = PR_SetPointer (&test_pr, pr_argv); test_pr.pr_argc = 2; + PR_ExecuteProgram (&test_pr, main_func); PR_PopFrame (&test_pr); if (options.flote) From 234f2212d622f4109dd5340e5776abab1b7a57aa Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 22 Jan 2022 16:00:04 +0900 Subject: [PATCH 198/360] [gamecode] Run an audit of progs parameter setup nq was just a bit of whitespace, but qw had an actual bug where the parameters were not being reset before writing to them. It really doesn't help that I don't know where to get progs suitable for testing (really don't what to have to write my own). --- nq/source/host.c | 3 +-- nq/source/sv_main.c | 3 +-- qw/source/sv_pr_cpqw.c | 1 + 3 files changed, 3 insertions(+), 4 deletions(-) diff --git a/nq/source/host.c b/nq/source/host.c index 907250a5c..601d5d335 100644 --- a/nq/source/host.c +++ b/nq/source/host.c @@ -386,8 +386,7 @@ SV_DropClient (qboolean crash) // call the prog function for removing a client // this will set the body to a dead frame, among other things saveSelf = *sv_globals.self; - *sv_globals.self = - EDICT_TO_PROG (&sv_pr_state, host_client->edict); + *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, host_client->edict); PR_ExecuteProgram (&sv_pr_state, sv_funcs.ClientDisconnect); *sv_globals.self = saveSelf; } diff --git a/nq/source/sv_main.c b/nq/source/sv_main.c index f11f1389d..d1d795de8 100644 --- a/nq/source/sv_main.c +++ b/nq/source/sv_main.c @@ -1087,8 +1087,7 @@ SV_SaveSpawnparms (void) continue; // call the progs to get default spawn parms for the new client - *sv_globals.self = - EDICT_TO_PROG (&sv_pr_state, host_client->edict); + *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, host_client->edict); PR_ExecuteProgram (&sv_pr_state, sv_funcs.SetChangeParms); for (j = 0; j < NUM_SPAWN_PARMS; j++) host_client->spawn_parms[j] = sv_globals.parms[j]; diff --git a/qw/source/sv_pr_cpqw.c b/qw/source/sv_pr_cpqw.c index eebb91ef4..f331b7e32 100644 --- a/qw/source/sv_pr_cpqw.c +++ b/qw/source/sv_pr_cpqw.c @@ -817,6 +817,7 @@ cpqw_user_cmd (void) *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, sv_player); PR_PushFrame (pr); + PR_RESET_PARAMS (pr); P_FLOAT (pr, 0) = argc; for (i = 1; i < argc + 1; i++) P_STRING (pr, i) = PR_SetTempString (pr, Cmd_Argv (i - 1)); From 861e98725c92e1cdd7f027a02e15c9c07fc44f5d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 22 Jan 2022 21:41:35 +0900 Subject: [PATCH 199/360] [gamecode] Return early if the entered function has no locals As even the simplest v6p functions that take parameters but have no local or temporary variables still have locals for the local copy of the parameters, this is a both a good check for for the Ruamoko ISA as its functions never have locals (everything's on the progs data stack), and an optimization for v6p functions that have no params or locals (simple getters (very rare?), most .ctor, etc). --- libs/gamecode/pr_exec.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 9d8469185..a7389f54a 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -229,6 +229,14 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) PR_PushFrame (pr); + //Sys_Printf("%s:\n", PR_GetString(pr,f->name)); + pr->pr_xfunction = f; + pr->pr_xstatement = f->first_statement - 1; // offset the st++ + + if (!f->locals) { + return; + } + if (f->numparms > 0) { paramofs = f->parm_start; for (i = 0; i < f->numparms; i++) { @@ -267,10 +275,6 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) } } - //Sys_Printf("%s:\n", PR_GetString(pr,f->name)); - pr->pr_xfunction = f; - pr->pr_xstatement = f->first_statement - 1; // offset the st++ - // save off any locals that the new function steps on if (pr->localstack_used + f->locals > PR_LOCAL_STACK_SIZE) PR_RunError (pr, "PR_EnterFunction: locals stack overflow"); From ec5830f70b380af3c7390bb5f84c7b55763113a8 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 23 Jan 2022 00:59:38 +0900 Subject: [PATCH 200/360] [qfcc] "Use" the correct operands The problem was a missed change when switching the internal statement format to Ruamoko: I "used" the statement's operands directly rather than the rotated ones when emitting v6p progs. Fixes a compile segfault when NOT optimizing. --- tools/qfcc/source/emit.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tools/qfcc/source/emit.c b/tools/qfcc/source/emit.c index 60dd095d2..30b2d1b4b 100644 --- a/tools/qfcc/source/emit.c +++ b/tools/qfcc/source/emit.c @@ -203,11 +203,11 @@ emit_statement (statement_t *statement) op_c = statement->opc; } def_a = get_operand_def (statement->expr, op_a); - use_tempop (statement->opa, statement->expr); + use_tempop (op_a, statement->expr); def_b = get_operand_def (statement->expr, op_b); - use_tempop (statement->opb, statement->expr); + use_tempop (op_b, statement->expr); def_c = get_operand_def (statement->expr, op_c); - use_tempop (statement->opc, statement->expr); + use_tempop (op_c, statement->expr); inst = opcode_find (opcode, op_a, op_b, op_c); if (!inst) { From b6093e07282c4ac8cc734301f279377eebb05954 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 23 Jan 2022 01:31:50 +0900 Subject: [PATCH 201/360] [qfcc] Add failing test for lost var use Storing a variable into a dereference pointer (*p = x) is not marking the variable as used (due to a mistake while converting to Ruamoko statement format) resulting in assignments to that variable being dropped due to it being a dead assignment as the assignment to the variable and the storing need to be in separate basic blocks (thus the call in the test, though an if would have worked, I think) for the bug to trigger. --- tools/qfcc/test/Makemodule.am | 11 +++++++++++ tools/qfcc/test/lost-use.r | 29 +++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+) create mode 100644 tools/qfcc/test/lost-use.r diff --git a/tools/qfcc/test/Makemodule.am b/tools/qfcc/test/Makemodule.am index 1f310048a..88b9e8480 100644 --- a/tools/qfcc/test/Makemodule.am +++ b/tools/qfcc/test/Makemodule.am @@ -31,6 +31,7 @@ test_progs_dat=\ tools/qfcc/test/infloop.dat \ tools/qfcc/test/ivar-struct-return.dat \ tools/qfcc/test/link_order.dat \ + tools/qfcc/test/lost-use.dat \ tools/qfcc/test/methodparams.dat \ tools/qfcc/test/modulo.dat \ tools/qfcc/test/nilparamret.dat \ @@ -386,6 +387,16 @@ tools/qfcc/test/link_order.run: $(qfcc_test_run_deps) include $(link_order_dep) # am--include-marker r_depfiles_remade += $(link_order_dep) +tools_qfcc_test_lost_use_dat_SOURCES=tools/qfcc/test/lost-use.r +lost_use_obj=$(tools_qfcc_test_lost_use_dat_SOURCES:.r=.o) +lost_use_dep=$(call qcautodep,$(tools_qfcc_test_lost_use_dat_SOURCES)) +tools/qfcc/test/lost-use.dat$(EXEEXT): $(lost_use_obj) $(QFCC_DEP) + $(V_QFCCLD)$(QLINK) -o $@ $(lost_use_obj) +tools/qfcc/test/lost-use.run: $(qfcc_test_run_deps) + @$(top_srcdir)/tools/qfcc/test/build-run $@ +include $(lost_use_dep) # am--include-marker +r_depfiles_remade += $(lost_use_dep) + tools_qfcc_test_methodparams_dat_SOURCES=tools/qfcc/test/methodparams.r methodparams_obj=$(tools_qfcc_test_methodparams_dat_SOURCES:.r=.o) methodparams_dep=$(call qcautodep,$(tools_qfcc_test_methodparams_dat_SOURCES)) diff --git a/tools/qfcc/test/lost-use.r b/tools/qfcc/test/lost-use.r new file mode 100644 index 000000000..dc9d79142 --- /dev/null +++ b/tools/qfcc/test/lost-use.r @@ -0,0 +1,29 @@ +void printf (string fmt, ...) = #0; +int getval(void) +{ + return 42; +} + +void magic (void) +{ +} + +void storeval (int *p) +{ + int x = getval (); + magic (); + *p = x; +} + +int val; + +int +main(void) +{ + storeval (&val); + if (val != 42) { + printf ("val is dead: %d\n", val); + return 1; + } + return 0; +} From adf672e7b17a4e26f13d603be742c5b1b910bc76 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 23 Jan 2022 01:37:57 +0900 Subject: [PATCH 202/360] [qfcc] Mark the correct operand as used in stores This fixes the lost-use test, and windows not dragging properly in qwaq-curses. Another single-character bug-fix :P --- tools/qfcc/source/flow.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/qfcc/source/flow.c b/tools/qfcc/source/flow.c index 8db692667..753b15928 100644 --- a/tools/qfcc/source/flow.c +++ b/tools/qfcc/source/flow.c @@ -1225,7 +1225,7 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, src_op = s->opa; aux_op2 = s->opc; } else if (!strcmp (s->opcode, "store")) { - flow_add_op_var (use, s->opb, 1); + flow_add_op_var (use, s->opc, 1); res_op = flow_analyze_pointer_operand (s->opa, def); src_op = s->opc; aux_op2 = s->opa; From f72e8ef551d85e472b83ef5e5ccd1a568d3e96a5 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 23 Jan 2022 02:04:28 +0900 Subject: [PATCH 203/360] [qwaq] Fix a couple of errors in debug Update qdb_get_string's mangling for qfcc's new unsigned int support and fix an incorrect cast of the param pointer passed by prd_runerror that caused a segfault when trying to use the string. Attempting to use qwaq-app (ie, the qc debugger) on Ruamoko ISA progs mostly works, but the defs are decidedly unhappy (due to the base registers). --- ruamoko/qwaq/builtins/debug.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ruamoko/qwaq/builtins/debug.c b/ruamoko/qwaq/builtins/debug.c index ba43ddcb5..2738a8589 100644 --- a/ruamoko/qwaq/builtins/debug.c +++ b/ruamoko/qwaq/builtins/debug.c @@ -378,7 +378,7 @@ qdb_get_event (progs_t *pr) break; case prd_runerror: case prd_error: - event->message = PR_SetReturnString (pr, *(char **) target->param); + event->message = PR_SetReturnString (pr, (char *) target->param); break; case prd_begin: event->function = *(pr_func_t *) target->param; @@ -661,7 +661,7 @@ static builtin_t builtins[] = { {"qdb_get_stack", qdb_get_stack, -1}, {"qdb_get_event", qdb_get_event, -1}, {"qdb_get_data", qdb_get_data, -1}, - {"qdb_get_string|{tag qdb_target_s=}i", qdb_get_string, -1}, + {"qdb_get_string|{tag qdb_target_s=}I", qdb_get_string, -1}, {"qdb_get_string|{tag qdb_target_s=}*", qdb_get_string, -1}, {"qdb_get_file_path", qdb_get_file_path, -1}, {"qdb_find_string", qdb_find_string, -1}, From cfaf158ebcb68cdc54b039100aa2f7be36e471fc Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 23 Jan 2022 13:47:14 +0900 Subject: [PATCH 204/360] [math] Add some bit-op functions Just 32-bit rounding to next higher power of two, and base 2 logarithm. Most importantly, they are suitable for use in initializers as they are constant in, constant out. --- include/QF/Makemodule.am | 1 + include/QF/math/bitop.h | 73 ++++++++++++++++++++++++++++++++++++ libs/util/test/Makemodule.am | 5 +++ libs/util/test/test-bitop.c | 55 +++++++++++++++++++++++++++ 4 files changed, 134 insertions(+) create mode 100644 include/QF/math/bitop.h create mode 100644 libs/util/test/test-bitop.c diff --git a/include/QF/Makemodule.am b/include/QF/Makemodule.am index 3892a430e..d36dd7ead 100644 --- a/include/QF/Makemodule.am +++ b/include/QF/Makemodule.am @@ -115,6 +115,7 @@ include_qf_input = \ include/QF/input/imt.h include_qf_math = \ + include/QF/math/bitop.h \ include/QF/math/dual.h \ include/QF/math/half.h \ include/QF/math/matrix3.h \ diff --git a/include/QF/math/bitop.h b/include/QF/math/bitop.h new file mode 100644 index 000000000..ee00ac6ca --- /dev/null +++ b/include/QF/math/bitop.h @@ -0,0 +1,73 @@ +/* + bitop.h + + bit-op functions + + Copyright (C) 2022 Bill Currie + + Author: Bill Currie + Date: 2022/1/23 + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + +*/ + +#ifndef __QF_math_bitop_h +#define __QF_math_bitop_h + +/** \defgroup mathlib_bitop Bit-op functions + \ingroup utils +*/ +///@{ + +#include "QF/qtypes.h" + +#define BITOP_RUP1__(x) ( (x) | ( (x) >> 1)) +#define BITOP_RUP2__(x) (BITOP_RUP1__(x) | (BITOP_RUP1__(x) >> 2)) +#define BITOP_RUP4__(x) (BITOP_RUP2__(x) | (BITOP_RUP2__(x) >> 4)) +#define BITOP_RUP8__(x) (BITOP_RUP4__(x) | (BITOP_RUP4__(x) >> 8)) +#define BITOP_RUP16__(x) (BITOP_RUP8__(x) | (BITOP_RUP8__(x) >> 16)) +/** Round x up to the next power of two. + + Rounds x up to the next power of two leaving exact powers of two + untouched. + + \param x The value to round + \return The next higher power of two or x if it already is a power + of two. +*/ +#define BITOP_RUP(x) (BITOP_RUP16__((uint32_t)(x) - 1) + 1) + +#define BITOP_LOG2__(x) (((((x) & 0xffff0000) != 0) << 4) \ + |((((x) & 0xff00ff00) != 0) << 3) \ + |((((x) & 0xf0f0f0f0) != 0) << 2) \ + |((((x) & 0xcccccccc) != 0) << 1) \ + |((((x) & 0xaaaaaaaa) != 0) << 0)) +/** Log base 2 rounded up. + + Finds the base 2 logarithm of x rounded up (ceil(log2(x))). + + \param x The value for which to find the base 2 logarithm. + \return Log base 2 of x, rounded up (2 -> 1, 3 -> 2, 4 -> 2) +*/ +#define BITOP_LOG2(x) BITOP_LOG2__(BITOP_RUP(x)) + +///@} + +#endif // __QF_math_bitop_h diff --git a/libs/util/test/Makemodule.am b/libs/util/test/Makemodule.am index 188239e11..7fa5a5f98 100644 --- a/libs/util/test/Makemodule.am +++ b/libs/util/test/Makemodule.am @@ -1,6 +1,7 @@ libs_util_tests = \ libs/util/test/test-bary \ libs/util/test/test-baryvf \ + libs/util/test/test-bitop \ libs/util/test/test-bsearch \ libs/util/test/test-cexpr \ libs/util/test/test-cmem \ @@ -36,6 +37,10 @@ libs_util_test_test_baryvf_SOURCES=libs/util/test/test-baryvf.c libs_util_test_test_baryvf_LDADD=libs/util/libQFutil.la libs_util_test_test_baryvf_DEPENDENCIES=libs/util/libQFutil.la +libs_util_test_test_bitop_SOURCES=libs/util/test/test-bitop.c +libs_util_test_test_bitop_LDADD=libs/util/libQFutil.la +libs_util_test_test_bitop_DEPENDENCIES=libs/util/libQFutil.la + libs_util_test_test_bsearch_SOURCES=libs/util/test/test-bsearch.c libs_util_test_test_bsearch_LDADD=libs/util/libQFutil.la libs_util_test_test_bsearch_DEPENDENCIES=libs/util/libQFutil.la diff --git a/libs/util/test/test-bitop.c b/libs/util/test/test-bitop.c new file mode 100644 index 000000000..795d023f5 --- /dev/null +++ b/libs/util/test/test-bitop.c @@ -0,0 +1,55 @@ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif +#include + +#include "QF/math/bitop.h" + +struct { + uint32_t value; + uint32_t expect; +} tests [] = { + {BITOP_RUP(1), 1}, + {BITOP_RUP(2), 2}, + {BITOP_RUP(3), 4}, + {BITOP_RUP(4), 4}, + {BITOP_RUP(5), 8}, + {BITOP_RUP(7), 8}, + {BITOP_RUP(8), 8}, + {BITOP_RUP(0x40000000), 0x40000000}, + {BITOP_RUP(0x40000001), 0x80000000}, + {BITOP_LOG2(1), 0}, + {BITOP_LOG2(2), 1}, + {BITOP_LOG2(3), 2}, + {BITOP_LOG2(4), 2}, + {BITOP_LOG2(5), 3}, + {BITOP_LOG2(7), 3}, + {BITOP_LOG2(8), 3}, + {BITOP_LOG2(9), 4}, + {BITOP_LOG2(15), 4}, + {BITOP_LOG2(16), 4}, + {BITOP_LOG2(17), 5}, + {BITOP_LOG2(31), 5}, + {BITOP_LOG2(32), 5}, + {BITOP_LOG2(33), 6}, + {BITOP_LOG2(0x40000000), 30}, + {BITOP_LOG2(0x40000001), 31}, +}; +#define num_tests (sizeof (tests) / sizeof (tests[0])) + +int +main (int argc, const char **argv) +{ + size_t i; + int res = 0; + + for (i = 0; i < num_tests; i++) { + if (tests[i].value != tests[i].expect) { + res |= 1; + printf ("test %d failed\n", (int) i); + printf ("expect: %8x\n", tests[i].expect); + printf ("got : %8x\n", tests[i].value); + } + } + return res; +} From 3c86660d4a56547830d9cfcae3ab94a721004492 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 23 Jan 2022 14:17:25 +0900 Subject: [PATCH 205/360] [gamecode] Rename MAX_PARMS to PR_MAXPARAMS --- include/QF/progs.h | 6 +++--- include/QF/progs/pr_comp.h | 4 ++-- libs/gamecode/pr_debug.c | 2 +- libs/gamecode/pr_exec.c | 6 +++--- libs/gamecode/pr_resolve.c | 2 +- libs/gamecode/pr_v6p_opcode.c | 2 +- libs/ruamoko/rua_obj.c | 2 +- qw/source/sv_pr_cmds.c | 2 +- tools/qfcc/source/expr.c | 8 ++++---- tools/qfcc/source/function.c | 4 ++-- tools/qfcc/source/method.c | 4 ++-- 11 files changed, 21 insertions(+), 21 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 3da8bca00..bf96afca0 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1205,7 +1205,7 @@ typedef struct { pr_int_t locals; pr_uint_t profile; pr_int_t numparms; - dparmsize_t parm_size[MAX_PARMS]; + dparmsize_t parm_size[PR_MAX_PARAMS]; dfunction_t *descriptor; builtin_proc func; } bfunction_t; @@ -1896,8 +1896,8 @@ struct progs_s { /// \name parameter block ///@{ pr_type_t *pr_return; - pr_type_t *pr_params[MAX_PARMS]; - pr_type_t *pr_real_params[MAX_PARMS]; + pr_type_t *pr_params[PR_MAX_PARAMS]; + pr_type_t *pr_real_params[PR_MAX_PARAMS]; int pr_param_size; ///< covers both params and return int pr_param_alignment; ///< covers both params and return pr_type_t pr_return_buffer[32];///< for discarded return values diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 22d7e0dc8..98de7cae0 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -506,7 +506,7 @@ typedef struct dparmsize_s { #define DEF_SAVEGLOBAL (1<<15) -#define MAX_PARMS 8 +#define PR_MAX_PARAMS 8 typedef struct dfunction_s { pr_int_t first_statement; // negative numbers are builtins @@ -519,7 +519,7 @@ typedef struct dfunction_s { pr_string_t file; // source file defined in pr_int_t numparms; // -ve is varargs (1s comp of real count) - dparmsize_t parm_size[MAX_PARMS]; + dparmsize_t parm_size[PR_MAX_PARAMS]; } dfunction_t; typedef union pr_type_u { diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 0a3d00e8b..a30aa8c66 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -1612,7 +1612,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) opchar = fmt[3]; parm_ind = fmt[2] - '0'; fmt++; // P has one extra item - if (parm_ind >= MAX_PARMS) + if (parm_ind >= PR_MAX_PARAMS) goto err; } diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index a7389f54a..0d8424857 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -219,7 +219,7 @@ static void PR_EnterFunction (progs_t *pr, bfunction_t *f) { pr_int_t i; - pr_type_t *dstParams[MAX_PARMS]; + pr_type_t *dstParams[PR_MAX_PARAMS]; pr_ptr_t paramofs = 0; if (pr->pr_trace && !pr->debug_handler) { @@ -263,7 +263,7 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) } dparmsize_t parmsize = { pr->pr_param_size, pr->pr_param_alignment }; paramofs = align_offset (paramofs, parmsize ); - if (i < MAX_PARMS) { + if (i < PR_MAX_PARAMS) { dstParams[i] = pr->pr_globals + paramofs; } for (; i < pr->pr_argc; i++) { @@ -303,7 +303,7 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) copy_args = pr->pr_argc - i; argc->int_var = copy_args; argv->int_var = dstParams[i] - pr->pr_globals; - if (i < MAX_PARMS) { + if (i < PR_MAX_PARAMS) { memcpy (dstParams[i], pr->pr_params[i], (copy_args * pr->pr_param_size) * sizeof (pr_type_t)); } diff --git a/libs/gamecode/pr_resolve.c b/libs/gamecode/pr_resolve.c index 299f8d2ae..992aff74e 100644 --- a/libs/gamecode/pr_resolve.c +++ b/libs/gamecode/pr_resolve.c @@ -129,7 +129,7 @@ PR_ResolveGlobals (progs_t *pr) if (!(def = PR_FindGlobal (pr, sym = ".return"))) goto error; pr->pr_return = &pr->pr_globals[def->ofs]; - for (i = 0; i < MAX_PARMS; i++) { + for (i = 0; i < PR_MAX_PARAMS; i++) { param_n[sizeof (param_str) - 2] = i + '0'; if (!(def = PR_FindGlobal (pr, sym = param_n))) goto error; diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index 2e9514a93..94da01a4c 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -1508,7 +1508,7 @@ is_vector_parameter_store (progs_t *pr, dstatement_t *st, return 0; if (operand != st->a) return 0; - for (i = 0; i < MAX_PARMS; i++) + for (i = 0; i < PR_MAX_PARAMS; i++) if (st->b == pr->pr_params[i] - pr->pr_globals) return 1; return 0; diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index 092562d50..10a5e165d 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -1412,7 +1412,7 @@ rua_obj_msg_sendv (progs_t *pr) int count = args->count; pr_type_t *params = G_GPOINTER (pr, args->list); - if (count < 2 || count > MAX_PARMS) { + if (count < 2 || count > PR_MAX_PARAMS) { PR_RunError (pr, "bad args count in obj_msg_sendv: %d", count); } if (pr_boundscheck->int_val) { diff --git a/qw/source/sv_pr_cmds.c b/qw/source/sv_pr_cmds.c index 1431729ee..d6ecf086b 100644 --- a/qw/source/sv_pr_cmds.c +++ b/qw/source/sv_pr_cmds.c @@ -1115,7 +1115,7 @@ PF_WriteBytes (progs_t *pr) { int i, p; int count = pr->pr_argc - 1; - byte buf[MAX_PARMS]; + byte buf[PR_MAX_PARAMS]; for (i = 0; i < count; i++) { p = P_FLOAT (pr, i + 1); diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 9395d699c..c0b291789 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -2029,8 +2029,8 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) int arg_count = 0, parm_count = 0; int i; expr_t *args = 0, **a = &args; - type_t *arg_types[MAX_PARMS]; - expr_t *arg_exprs[MAX_PARMS][2]; + type_t *arg_types[PR_MAX_PARAMS]; + expr_t *arg_exprs[PR_MAX_PARAMS][2]; int arg_expr_count = 0; expr_t *assign; expr_t *call; @@ -2042,8 +2042,8 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) arg_count++; } - if (arg_count > MAX_PARMS) { - return error (fexpr, "more than %d parameters", MAX_PARMS); + if (arg_count > PR_MAX_PARAMS) { + return error (fexpr, "more than %d parameters", PR_MAX_PARAMS); } if (ftype->t.func.num_params < -1) { if (-arg_count > ftype->t.func.num_params + 1) { diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index a4d785d6d..ac148bf74 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -536,7 +536,7 @@ build_scope (symbol_t *fsym, symtab_t *parent) } if (args) { - while (i < MAX_PARMS) { + while (i < PR_MAX_PARAMS) { param = new_symbol_type (va (0, ".par%d", i), &type_param); initialize_def (param, 0, parameters->space, sc_param); i++; @@ -636,7 +636,7 @@ static void build_function (symbol_t *fsym) { const type_t *func_type = fsym->s.func->type; - if (func_type->t.func.num_params > MAX_PARMS) { + if (func_type->t.func.num_params > PR_MAX_PARAMS) { error (0, "too many params"); } } diff --git a/tools/qfcc/source/method.c b/tools/qfcc/source/method.c index b4cae8e08..f36a1fd20 100644 --- a/tools/qfcc/source/method.c +++ b/tools/qfcc/source/method.c @@ -710,8 +710,8 @@ method_check_params (method_t *method, expr_t *args) for (count = 0, a = args; a; a = a->next) count++; - if (count > MAX_PARMS) - return error (args, "more than %d parameters", MAX_PARMS); + if (count > PR_MAX_PARAMS) + return error (args, "more than %d parameters", PR_MAX_PARAMS); if (mtype->t.func.num_params >= 0) param_count = mtype->t.func.num_params; From e746e39738781eac7127da7464480049b95c4405 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 23 Jan 2022 14:27:36 +0900 Subject: [PATCH 206/360] [gamecode] Create macros for progs sizeof and alignof I wound up needing the idioms in too many places. --- include/QF/progs/pr_comp.h | 3 +++ libs/gamecode/pr_opcode.c | 4 ++-- tools/qfcc/source/type.c | 2 +- 3 files changed, 6 insertions(+), 3 deletions(-) diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 98de7cae0..88a644f62 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -62,6 +62,9 @@ typedef enum { ev_type_count // not a type, gives number of types } etype_t; +#define PR_SIZEOF(type) (sizeof (pr_##type##_t) / sizeof (pr_int_t)) +#define PR_ALIGNOF(type) (__alignof__ (pr_##type##_t) / __alignof__ (pr_int_t)) + extern const pr_ushort_t pr_type_size[ev_type_count]; extern const pr_ushort_t pr_type_alignment[ev_type_count]; extern const char * const pr_type_name[ev_type_count]; diff --git a/libs/gamecode/pr_opcode.c b/libs/gamecode/pr_opcode.c index 289f06a1f..34a36c242 100644 --- a/libs/gamecode/pr_opcode.c +++ b/libs/gamecode/pr_opcode.c @@ -33,13 +33,13 @@ #include "QF/progs.h" -#define EV_TYPE(type) (sizeof (pr_##type##_t) / sizeof (pr_int_t)), +#define EV_TYPE(type) PR_SIZEOF(type), VISIBLE const pr_ushort_t pr_type_size[ev_type_count] = { #include "QF/progs/pr_type_names.h" 0, // ev_invalid not a valid/simple type }; -#define EV_TYPE(type) (__alignof__ (pr_##type##_t) / __alignof__ (pr_int_t)), +#define EV_TYPE(type) PR_ALIGNOF(type), VISIBLE const pr_ushort_t pr_type_alignment[ev_type_count] = { #include "QF/progs/pr_type_names.h" 0, // ev_invalid not a valid/simple type diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index a52594af8..ceb0360a5 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -64,7 +64,7 @@ type_t type_##t = { \ .type = ev_##t, \ .name = #t, \ - .alignment = __alignof__(pr_##t##_t) / __alignof__ (pr_int_t), \ + .alignment = PR_ALIGNOF(t), \ .meta = ty_basic, \ {{ __builtin_choose_expr (ev_##t == ev_field \ || ev_##t == ev_func \ From a6b932025cd5ba37028fcd25a1f166e0d649e7a7 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 23 Jan 2022 21:54:03 +0900 Subject: [PATCH 207/360] [gamecode] Provide builtins with information about their parameters This will make it possible for the engine to set up their parameter pointers when running Ruamoko progs. At this stage, it doesn't matter *too* much, except for varargs functions, because no builtin yet takes anything larger than a float quaternion, but it will be critical when double or long vec3 and vec4 values are passed. --- include/QF/progs.h | 20 +++ libs/audio/snd_progs.c | 4 +- libs/console/bi_inputline.c | 26 ++-- libs/console/menu.c | 48 ++++--- libs/gib/bi_gib.c | 13 +- libs/ruamoko/pr_cmds.c | 68 +++++----- libs/ruamoko/rua_cbuf.c | 11 +- libs/ruamoko/rua_cmd.c | 10 +- libs/ruamoko/rua_cvar.c | 25 ++-- libs/ruamoko/rua_hash.c | 36 ++--- libs/ruamoko/rua_input.c | 66 ++++----- libs/ruamoko/rua_keys.c | 15 +- libs/ruamoko/rua_math.c | 92 +++++++------ libs/ruamoko/rua_mersenne.c | 15 +- libs/ruamoko/rua_msgbuf.c | 77 ++++++----- libs/ruamoko/rua_obj.c | 119 ++++++++-------- libs/ruamoko/rua_plist.c | 44 +++--- libs/ruamoko/rua_qfile.c | 45 +++--- libs/ruamoko/rua_qfs.c | 20 +-- libs/ruamoko/rua_runtime.c | 5 +- libs/ruamoko/rua_script.c | 18 +-- libs/ruamoko/rua_set.c | 140 ++++++++++--------- libs/ruamoko/rua_stdlib.c | 13 +- libs/ruamoko/rua_string.c | 39 +++--- libs/video/renderer/r_progs.c | 30 ++-- nq/source/sv_pr_cmds.c | 130 +++++++++--------- qw/source/sv_pr_cmds.c | 183 +++++++++++++------------ qw/source/sv_pr_cpqw.c | 38 +++--- qw/source/sv_pr_qwe.c | 45 +++--- qw/source/sv_user.c | 7 +- ruamoko/cl_menu/menu.r | 1 + ruamoko/lib/Object.r | 10 +- ruamoko/lib/Set.r | 1 + ruamoko/lib/key.r | 1 + ruamoko/qwaq/builtins/curses.c | 211 ++++++++++++++++------------- ruamoko/qwaq/builtins/debug.c | 48 +++---- ruamoko/qwaq/builtins/editbuffer.c | 142 +++++++++---------- ruamoko/qwaq/builtins/graphics.c | 14 +- ruamoko/qwaq/builtins/main.c | 8 +- ruamoko/qwaq/builtins/term-input.c | 10 +- tools/qfcc/test/test-bi.c | 14 +- 41 files changed, 1012 insertions(+), 850 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index bf96afca0..25f0d1a4e 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -33,6 +33,7 @@ \image latex vm-mem.eps "VM memory map" */ +#include "QF/math/bitop.h" #include "QF/progs/pr_comp.h" #include "QF/progs/pr_debug.h" @@ -1193,8 +1194,27 @@ typedef struct { /// The number of the builtin for \#N in QC. -1 for automatic allocation. /// 0 or >= ::PR_AUTOBUILTIN is invalid. pr_int_t binum; + /// The number of parameters the builtin takes. Negative numbers mean + /// varargs with ~num_params (-num_params - 1) being the number of real + /// parameters. + pr_int_t num_params; + /// Parameter size specificiation. + /// + /// Up to 8 parameters are supported for automatic parameter setup because + /// that's all that v6p progs can pass. Builtins taking more than 8 + /// parameters are already Ruamoko-only and thus know how to deal with the + /// parameters being on the data stack. + /// + /// The encoding is the same as for progs functions, with 3:5 for + /// alignment:size (size 0 means 32 words). + dparmsize_t params[PR_MAX_PARAMS]; } builtin_t; +#define PR_PARAM(type) { \ + .size = PR_SIZEOF(type) & 0x1f, \ + .alignment = BITOP_LOG2(PR_ALIGNOF(type)), \ +} + /** Duplicate the dfunction_t descriptor with the addition of a pointer to the builtin function. Avoids a level of indirection when calling a builtin function. diff --git a/libs/audio/snd_progs.c b/libs/audio/snd_progs.c index a130fd44c..8e77bdde7 100644 --- a/libs/audio/snd_progs.c +++ b/libs/audio/snd_progs.c @@ -47,8 +47,10 @@ bi_S_LocalSound (progs_t *pr) S_LocalSound (sound); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"S_LocalSound", bi_S_LocalSound, -1}, + bi(S_LocalSound, 1, p(string)), {0} }; diff --git a/libs/console/bi_inputline.c b/libs/console/bi_inputline.c index a2de6285c..af8fba096 100644 --- a/libs/console/bi_inputline.c +++ b/libs/console/bi_inputline.c @@ -302,21 +302,23 @@ bi_InputLine_Draw (progs_t *pr) line->line->draw (line->line); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"InputLine_Create", bi_InputLine_Create, -1}, - {"InputLine_SetPos", bi_InputLine_SetPos, -1}, - {"InputLine_SetCursor", bi_InputLine_SetCursor, -1}, + bi(InputLine_Create, 3, p(int), p(int), p(int)), + bi(InputLine_SetPos, 3, p(ptr), p(int), p(int)), + bi(InputLine_SetCursor, 2, p(ptr), p(int)), {"InputLine_SetEnter|^{tag _inputline_t=}(v*^v)^v", - bi_InputLine_SetEnter, -1}, + bi_InputLine_SetEnter, -1, 3, {p(ptr), p(func), p(ptr)}}, {"InputLine_SetEnter|^{tag _inputline_t=}(@@:.)@:", - bi_InputLine_SetEnter, -1}, - {"InputLine_SetWidth", bi_InputLine_SetWidth, -1}, - {"InputLine_SetText", bi_InputLine_SetText, -1}, - {"InputLine_GetText", bi_InputLine_GetText, -1}, - {"InputLine_Destroy", bi_InputLine_Destroy, -1}, - {"InputLine_Clear", bi_InputLine_Clear, -1}, - {"InputLine_Process", bi_InputLine_Process, -1}, - {"InputLine_Draw", bi_InputLine_Draw, -1}, + bi_InputLine_SetEnter, -1, 4, {p(ptr), p(func), p(ptr), p(ptr)}}, + bi(InputLine_SetWidth, 2, p(ptr), p(int)), + bi(InputLine_SetText, 2, p(ptr), p(string)), + bi(InputLine_GetText, 1, p(ptr)), + bi(InputLine_Destroy, 1, p(ptr)), + bi(InputLine_Clear, 2, p(ptr), p(int)), + bi(InputLine_Process, 2, p(ptr), p(int)), + bi(InputLine_Draw, 1, p(ptr)), {0} }; diff --git a/libs/console/menu.c b/libs/console/menu.c index 80bcc772e..aea52cefc 100644 --- a/libs/console/menu.c +++ b/libs/console/menu.c @@ -513,29 +513,33 @@ menu_load_file (progs_t *pr, const char *path, off_t *size) return data; } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"Menu_Begin", bi_Menu_Begin, -1}, - {"Menu_FadeScreen", bi_Menu_FadeScreen, -1}, - {"Menu_Draw", bi_Menu_Draw, -1}, - {"Menu_EnterHook", bi_Menu_EnterHook, -1}, - {"Menu_LeaveHook", bi_Menu_LeaveHook, -1}, - {"Menu_Pic", bi_Menu_Pic, -1}, - {"Menu_SubPic", bi_Menu_SubPic, -1}, - {"Menu_CenterPic", bi_Menu_CenterPic, -1}, - {"Menu_CenterSubPic", bi_Menu_CenterSubPic, -1}, - {"Menu_Item", bi_Menu_Item, -1}, - {"Menu_Cursor", bi_Menu_Cursor, -1}, - {"Menu_KeyEvent", bi_Menu_KeyEvent, -1}, - {"Menu_End", bi_Menu_End, -1}, - {"Menu_TopMenu", bi_Menu_TopMenu, -1}, - {"Menu_SelectMenu", bi_Menu_SelectMenu, -1}, - {"Menu_SetQuit", bi_Menu_SetQuit, -1}, - {"Menu_Quit", bi_Menu_Quit, -1}, - {"Menu_GetIndex", bi_Menu_GetIndex, -1}, - {"Menu_Next", bi_Menu_Next, -1}, - {"Menu_Prev", bi_Menu_Prev, -1}, - {"Menu_Enter", bi_Menu_Enter, -1}, - {"Menu_Leave", bi_Menu_Leave, -1}, + bi(Menu_Begin, 3, p(int), p(int), p(string)), + bi(Menu_FadeScreen, 1, p(int)), + bi(Menu_Draw, 2, p(int), p(int)), + bi(Menu_EnterHook, 1, p(func)), + bi(Menu_LeaveHook, 1, p(func)), + bi(Menu_Pic, 3, p(int), p(int), p(string)), + bi(Menu_SubPic, 7, p(int), p(int), p(string), + p(int), p(int), p(int), p(int)), + bi(Menu_CenterPic, 3, p(int), p(int), p(string)), + bi(Menu_CenterSubPic, 7, p(int), p(int), p(string), + p(int), p(int), p(int), p(int)), + bi(Menu_Item, 5, p(int), p(int), p(string), p(func), p(int)), + bi(Menu_Cursor, 1, p(func)), + bi(Menu_KeyEvent, 1, p(func)), + bi(Menu_End, 0), + bi(Menu_TopMenu, 1, p(string)), + bi(Menu_SelectMenu, 1, p(string)), + bi(Menu_SetQuit, 1, p(func)), + bi(Menu_Quit, 0), + bi(Menu_GetIndex, 0), + bi(Menu_Next, 0), + bi(Menu_Prev, 0), + bi(Menu_Enter, 0), + bi(Menu_Leave, 0), {0}, }; diff --git a/libs/gib/bi_gib.c b/libs/gib/bi_gib.c index f2f9bc671..28d5401c0 100644 --- a/libs/gib/bi_gib.c +++ b/libs/gib/bi_gib.c @@ -175,12 +175,15 @@ bi_GIB_Handle_Get (progs_t *pr) // R_INT (pr) = 0; } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"GIB_Builtin_Add", bi_GIB_Builtin_Add, -1}, - {"GIB_Return", bi_GIB_Return, -1}, - {"GIB_Handle_New", bi_GIB_Handle_New, -1}, - {"GIB_Handle_Free", bi_GIB_Handle_Free, -1}, - {"GIB_Handle_Get", bi_GIB_Handle_Get, -1}, + bi(GIB_Builtin_Add, 2, p(string), p(func)), + bi(GIB_Return, 1, p(string)), + bi(GIB_Handle_New, 0),//FIXME + bi(GIB_Handle_Free, 0),//FIXME + bi(GIB_Handle_Get, 0),//FIXME {0} }; diff --git a/libs/ruamoko/pr_cmds.c b/libs/ruamoko/pr_cmds.c index 5aed0b2a4..7c70b82d6 100644 --- a/libs/ruamoko/pr_cmds.c +++ b/libs/ruamoko/pr_cmds.c @@ -249,7 +249,7 @@ PF_fabs (progs_t *pr) entity (entity start, .(...) fld, ... match) find */ static void -PF_Find (progs_t *pr) +PF_find (progs_t *pr) { const char *s = 0, *t; // ev_string int i; // ev_vector @@ -557,7 +557,7 @@ PF_charcount (progs_t *pr) string () gametype */ static void -PR_gametype (progs_t *pr) +PF_gametype (progs_t *pr) { RETURN_STRING (pr, pr_gametype); } @@ -585,41 +585,43 @@ PF_PR_FindFunction (progs_t *pr) #define QF (PR_RANGE_QF << PR_RANGE_SHIFT) | +#define bi(x,n,np,params...) {#x, PF_##x, n, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"break", PF_break, 6}, - {"random", PF_random, 7}, - {"normalize", PF_normalize, 9}, - {"vlen", PF_vlen, 12}, - {"vectoyaw", PF_vectoyaw, 13}, - {"find", PF_Find, 18}, - {"dprint", PF_dprint, 25}, - {"ftos", PF_ftos, 26}, - {"vtos", PF_vtos, 27}, - {"coredump", PF_coredump, 28}, - {"traceon", PF_traceon, 29}, - {"traceoff", PF_traceoff, 30}, - {"eprint", PF_eprint, 31}, - {"rint", PF_rint, 36}, - {"floor", PF_floor, 37}, - {"ceil", PF_ceil, 38}, - {"fabs", PF_fabs, 43}, - {"cvar", PF_cvar, 45}, - {"nextent", PF_nextent, 47}, - {"vectoangles", PF_vectoangles, 51}, - {"cvar_set", PF_cvar_set, 72}, - {"stof", PF_stof, 81}, + bi(break, 6, 0), + bi(random, 7, 0), + bi(normalize, 9, 1, p(vector)), + bi(vlen, 12, 1, p(vector)), + bi(vectoyaw, 13, 1, p(vector)), + bi(find, 18, -3, p(entity), p(field)), + bi(dprint, 25, -1), + bi(ftos, 26, 1, p(float)), + bi(vtos, 27, 1, p(vector)), + bi(coredump, 28, 0), + bi(traceon, 29, 0), + bi(traceoff, 30, 0), + bi(eprint, 31, 1, p(entity)), + bi(rint, 36, 1, p(float)), + bi(floor, 37, 1, p(float)), + bi(ceil, 38, 1, p(float)), + bi(fabs, 43, 1, p(float)), + bi(cvar, 45, 1, p(string)), + bi(nextent, 47, 1, p(entity)), + bi(vectoangles, 51, 1, p(vector)), + bi(cvar_set, 72, 2, p(string), p(string)), + bi(stof, 81, 1, p(string)), - {"charcount", PF_charcount, QF 101}, - {"ftoi", PF_ftoi, QF 110}, - {"itof", PF_itof, QF 111}, - {"itos", PF_itos, QF 112}, - {"stoi", PF_stoi, QF 113}, - {"stov", PF_stov, QF 114}, - {"gametype", PR_gametype, QF 115}, + bi(charcount, QF 101, 2, p(string), p(string)), + bi(ftoi, QF 110, 1, p(float)), + bi(itof, QF 111, 1, p(int)), + bi(itos, QF 112, 1, p(int)), + bi(stoi, QF 113, 1, p(string)), + bi(stov, QF 114, 1, p(string)), + bi(gametype, QF 115, 0), - {"PR_SetField", PF_PR_SetField, -1}, - {"PR_FindFunction", PF_PR_FindFunction, -1}, + bi(PR_SetField, -1, 3, p(entity), p(string), p(string)), + bi(PR_FindFunction, -1, 1, p(string)), {0} }; diff --git a/libs/ruamoko/rua_cbuf.c b/libs/ruamoko/rua_cbuf.c index 5d1bbc095..0a3870d80 100644 --- a/libs/ruamoko/rua_cbuf.c +++ b/libs/ruamoko/rua_cbuf.c @@ -93,11 +93,14 @@ bi_cbuf_clear (progs_t *pr, void *data) { } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"Cbuf_AddText", bi_Cbuf_AddText, -1}, - {"Cbuf_InsertText", bi_Cbuf_InsertText, -1}, - {"Cbuf_Execute", bi_Cbuf_Execute, -1}, - {"Cbuf_Execute_Sets", bi_Cbuf_Execute_Sets, -1}, + bi(Cbuf_AddText, 1, p(string)), + bi(Cbuf_InsertText, 1, p(string)), + bi(Cbuf_Execute, 0), + bi(Cbuf_Execute_Sets, 0), {0} }; diff --git a/libs/ruamoko/rua_cmd.c b/libs/ruamoko/rua_cmd.c index 44006b815..8be474e50 100644 --- a/libs/ruamoko/rua_cmd.c +++ b/libs/ruamoko/rua_cmd.c @@ -145,11 +145,13 @@ bi_Cmd_Args (progs_t *pr) //Cmd_ExecuteString //Cmd_ForwardToServer +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"Cmd_AddCommand", bi_Cmd_AddCommand, -1}, - {"Cmd_Argc", bi_Cmd_Argc, -1}, - {"Cmd_Argv", bi_Cmd_Argv, -1}, - {"Cmd_Args", bi_Cmd_Args, -1}, + bi(Cmd_AddCommand, 2, p(string), p(func)), + bi(Cmd_Argc, 0), + bi(Cmd_Argv, 1, p(int)), + bi(Cmd_Args, 1, p(int)), {0} }; diff --git a/libs/ruamoko/rua_cvar.c b/libs/ruamoko/rua_cvar.c index dbb652817..4cf68ee4f 100644 --- a/libs/ruamoko/rua_cvar.c +++ b/libs/ruamoko/rua_cvar.c @@ -232,18 +232,21 @@ bi_Cvar_Toggle (progs_t *pr) Cvar_Set (var, var->int_val ? "0" : "1"); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"Cvar_MakeAlias", bi_Cvar_MakeAlias, -1}, - {"Cvar_RemoveAlias", bi_Cvar_RemoveAlias, -1}, - {"Cvar_SetFloat", bi_Cvar_SetFloat, -1}, - {"Cvar_SetInteger", bi_Cvar_SetInteger, -1}, - {"Cvar_SetVector", bi_Cvar_SetVector, -1}, - {"Cvar_SetString", bi_Cvar_SetString, -1}, - {"Cvar_GetFloat", bi_Cvar_GetFloat, -1}, - {"Cvar_GetInteger", bi_Cvar_GetInteger, -1}, - {"Cvar_GetVector", bi_Cvar_GetVector, -1}, - {"Cvar_GetString", bi_Cvar_GetString, -1}, - {"Cvar_Toggle", bi_Cvar_Toggle, -1}, + bi(Cvar_MakeAlias, 2, p(string), p(string)), + bi(Cvar_RemoveAlias, 1, p(string)), + bi(Cvar_SetFloat, 2, p(string), p(float)), + bi(Cvar_SetInteger, 2, p(string), p(int)), + bi(Cvar_SetVector, 2, p(string), p(vector)), + bi(Cvar_SetString, 2, p(string), p(string)), + bi(Cvar_GetFloat, 1, p(string)), + bi(Cvar_GetInteger, 1, p(string)), + bi(Cvar_GetVector, 1, p(string)), + bi(Cvar_GetString, 1, p(string)), + bi(Cvar_Toggle, 1, p(string)), {0} }; diff --git a/libs/ruamoko/rua_hash.c b/libs/ruamoko/rua_hash.c index 3e9336398..a1b277706 100644 --- a/libs/ruamoko/rua_hash.c +++ b/libs/ruamoko/rua_hash.c @@ -359,24 +359,26 @@ bi_hash_clear (progs_t *pr, void *data) table_reset (res); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"Hash_NewTable", bi_Hash_NewTable, -1}, - {"Hash_SetHashCompare", bi_Hash_SetHashCompare, -1}, - {"Hash_DelTable", bi_Hash_DelTable, -1}, - {"Hash_FlushTable", bi_Hash_FlushTable, -1}, - {"Hash_Add", bi_Hash_Add, -1}, - {"Hash_AddElement", bi_Hash_AddElement, -1}, - {"Hash_Find", bi_Hash_Find, -1}, - {"Hash_FindElement", bi_Hash_FindElement, -1}, - {"Hash_FindList", bi_Hash_FindList, -1}, - {"Hash_FindElementList", bi_Hash_FindElementList, -1}, - {"Hash_Del", bi_Hash_Del, -1}, - {"Hash_DelElement", bi_Hash_DelElement, -1}, - {"Hash_Free", bi_Hash_Free, -1}, - {"Hash_String", bi_Hash_String, -1}, - {"Hash_Buffer", bi_Hash_Buffer, -1}, - {"Hash_GetList", bi_Hash_GetList, -1}, - {"Hash_Stats", bi_Hash_Stats, -1}, + bi(Hash_NewTable, 4, p(int), p(func), p(func), p(ptr)), + bi(Hash_SetHashCompare, 3, p(ptr), p(func), p(func)), + bi(Hash_DelTable, 1, p(ptr)), + bi(Hash_FlushTable, 1, p(ptr)), + bi(Hash_Add, 2, p(ptr), p(ptr)), + bi(Hash_AddElement, 2, p(ptr), p(ptr)), + bi(Hash_Find, 2, p(ptr), p(string)), + bi(Hash_FindElement, 2, p(ptr), p(ptr)), + bi(Hash_FindList, 2, p(ptr), p(string)), + bi(Hash_FindElementList, 2, p(ptr), p(ptr)), + bi(Hash_Del, 2, p(ptr), p(string)), + bi(Hash_DelElement, 2, p(ptr), p(ptr)), + bi(Hash_Free, 2, p(ptr), p(ptr)), + bi(Hash_String, 1, p(string)), + bi(Hash_Buffer, 2, p(ptr), p(int)), + bi(Hash_GetList, 1, p(ptr)), + bi(Hash_Stats, 1, p(ptr)), {0} }; diff --git a/libs/ruamoko/rua_input.c b/libs/ruamoko/rua_input.c index b838b3086..e93d88085 100644 --- a/libs/ruamoko/rua_input.c +++ b/libs/ruamoko/rua_input.c @@ -407,56 +407,58 @@ secured (progs_t *pr) PR_RunError (pr, "Secured function called"); } -#define bi(x) {#x, secured, -1} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } +#define bi(x,np,params...) {#x, secured, -1, np, {params}} static builtin_t secure_builtins[] = { - bi(IN_CreateButton), - bi(IN_CreateAxis), - bi(IN_LoadConfig), + bi(IN_CreateButton, 2, p(string), p(string)), + bi(IN_CreateAxis, 2, p(string), p(string)), + bi(IN_LoadConfig, 1, p(ptr)), {0} }; #undef bi -#define bi(x) {#x, bi_##x, -1} +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} static builtin_t insecure_builtins[] = { - bi(IN_CreateButton), - bi(IN_CreateAxis), - bi(IN_LoadConfig), + bi(IN_CreateButton, 2, p(string), p(string)), + bi(IN_CreateAxis, 2, p(string), p(string)), + bi(IN_LoadConfig, 1, p(ptr)), {0} }; static builtin_t builtins[] = { - bi(IN_FindDeviceId), - bi(IN_GetDeviceName), - bi(IN_GetDeviceId), - bi(IN_AxisInfo), - bi(IN_ButtonInfo), - bi(IN_GetAxisName), - bi(IN_GetButtonName), - bi(IN_GetAxisNumber), - bi(IN_GetButtonNumber), - bi(IN_ProcessEvents), - bi(IN_ClearStates), - bi(IN_GetAxisInfo), - bi(IN_GetButtonInfo), + bi(IN_FindDeviceId, 1, p(string)), + bi(IN_GetDeviceName, 1, p(int)), + bi(IN_GetDeviceId, 1, p(int)), + bi(IN_AxisInfo, 0), //FIXME + bi(IN_ButtonInfo, 0), //FIXME + bi(IN_GetAxisName, 2, p(int), p(int)), + bi(IN_GetButtonName, 2, p(int), p(int)), + bi(IN_GetAxisNumber, 2, p(int), p(string)), + bi(IN_GetButtonNumber, 2, p(int), p(string)), + bi(IN_ProcessEvents, 0), + bi(IN_ClearStates, 0), + bi(IN_GetAxisInfo, 3, p(int), p(int), p(ptr)), + bi(IN_GetButtonInfo, 3, p(int), p(int), p(ptr)), {"IN_ButtonAddListener|^{tag in_button_s=}^(v^v^{tag in_button_s=})^v", - rua_IN_ButtonAddListener_func, -1}, + rua_IN_ButtonAddListener_func, -1, 3, {p(ptr), p(func), p(ptr)}}, {"IN_ButtonRemoveListener|^{tag in_button_s=}^(v^v^{tag in_button_s=})^v", - rua_IN_ButtonRemoveListener_func, -1}, + rua_IN_ButtonRemoveListener_func, -1, 3, {p(ptr), p(func), p(ptr)}}, {"IN_AxisAddListener|^{tag in_axis_s=}^(v^v^{tag in_axis_s=})^v", - rua_IN_AxisAddListener_func, -1}, + rua_IN_AxisAddListener_func, -1, 3, {p(ptr), p(func), p(ptr)}}, {"IN_AxisRemoveListener|^{tag in_axis_s=}^(v^v^{tag in_axis_s=})^v", - rua_IN_AxisRemoveListener_func, -1}, + rua_IN_AxisRemoveListener_func, -1, 3, {p(ptr), p(func), p(ptr)}}, {"IN_ButtonAddListener|^{tag in_button_s=}(@@:.)@", - rua_IN_ButtonAddListener_method, -1}, + rua_IN_ButtonAddListener_method, -1, 3, {p(ptr), p(func), p(ptr)}}, {"IN_ButtonRemoveListener|^{tag in_button_s=}(@@:.)@", - rua_IN_ButtonRemoveListener_method, -1}, + rua_IN_ButtonRemoveListener_method, -1, 3, {p(ptr), p(func), p(ptr)}}, {"IN_AxisAddListener|^{tag in_axis_s=}(@@:.)@", - rua_IN_AxisAddListener_method, -1}, + rua_IN_AxisAddListener_method, -1, 3, {p(ptr), p(func), p(ptr)}}, {"IN_AxisRemoveListener|^{tag in_axis_s=}(@@:.)@", - rua_IN_AxisRemoveListener_method, -1}, + rua_IN_AxisRemoveListener_method, -1, 3, {p(ptr), p(func), p(ptr)}}, - bi(IMT_CreateContext), - bi(IMT_GetContext), - bi(IMT_SetContext), + bi(IMT_CreateContext, 1, p(string)), + bi(IMT_GetContext, 0), + bi(IMT_SetContext, 1, p(int)), {0} }; diff --git a/libs/ruamoko/rua_keys.c b/libs/ruamoko/rua_keys.c index 11747304e..2f09ae227 100644 --- a/libs/ruamoko/rua_keys.c +++ b/libs/ruamoko/rua_keys.c @@ -165,13 +165,16 @@ bi_Key_StringToKeynum (progs_t *pr) R_INT (pr) = Key_StringToKeynum (keyname); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"Key_keydown", bi_Key_keydown, -1}, - {"Key_SetBinding", bi_Key_SetBinding, -1}, - {"Key_LookupBinding", bi_Key_LookupBinding, -1}, - {"Key_CountBinding", bi_Key_CountBinding, -1}, - {"Key_KeynumToString", bi_Key_KeynumToString, -1}, - {"Key_StringToKeynum", bi_Key_StringToKeynum, -1}, + bi(Key_keydown, 1, p(int)), + bi(Key_SetBinding, 3, p(string), p(int), p(string)), + bi(Key_LookupBinding, 3, p(string), p(int), p(string)), + bi(Key_CountBinding, 2, p(string), p(string)), + bi(Key_KeynumToString, 1, p(int)), + bi(Key_StringToKeynum, 1, p(string)), {0} }; diff --git a/libs/ruamoko/rua_math.c b/libs/ruamoko/rua_math.c index f6926fa65..21d96fb6d 100644 --- a/libs/ruamoko/rua_math.c +++ b/libs/ruamoko/rua_math.c @@ -321,52 +321,54 @@ bi_atanh (progs_t *pr) R_DOUBLE (pr) = log ((1 + y) / (1 - y)) / 2; } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"sin|f", bi_sinf, -1}, - {"cos|f", bi_cosf, -1}, - {"tan|f", bi_tanf, -1}, - {"asin|f", bi_asinf, -1}, - {"acos|f", bi_acosf, -1}, - {"atan|f", bi_atanf, -1}, - {"atan2|ff",bi_atan2f, -1}, - {"exp|f", bi_expf, -1}, - {"log|f", bi_logf, -1}, - {"log2|f", bi_log2f, -1}, - {"log10|f", bi_log10f, -1}, - {"pow|ff", bi_powf, -1}, - {"sqrt|f", bi_sqrtf, -1}, - {"cbrt|f", bi_cbrtf, -1}, - {"hypot|ff",bi_hypotf, -1}, - {"sinh|f", bi_sinhf, -1}, - {"cosh|f", bi_coshf, -1}, - {"tanh|f", bi_tanhf, -1}, - {"asinh|f", bi_asinhf, -1}, - {"acosh|f", bi_acoshf, -1}, - {"atanh|f", bi_atanhf, -1}, - {"floor|d", bi_floor, -1}, // float version in pr_cmds - {"ceil|d", bi_ceil, -1}, // float version in pr_cmds - {"fabs|d", bi_fabs, -1}, // float version in pr_cmds - {"sin|d", bi_sin, -1}, - {"cos|d", bi_cos, -1}, - {"tan|d", bi_tan, -1}, - {"asin|d", bi_asin, -1}, - {"acos|d", bi_acos, -1}, - {"atan|d", bi_atan, -1}, - {"atan2|dd",bi_atan2, -1}, - {"exp|d", bi_exp, -1}, - {"log|d", bi_log, -1}, - {"log2|d", bi_log2, -1}, - {"log10|d", bi_log10, -1}, - {"pow|dd", bi_pow, -1}, - {"sqrt|d", bi_sqrt, -1}, - {"cbrt|d", bi_cbrt, -1}, - {"hypot|dd",bi_hypot, -1}, - {"sinh|d", bi_sinh, -1}, - {"cosh|d", bi_cosh, -1}, - {"tanh|d", bi_tanh, -1}, - {"asinh|d", bi_asinh, -1}, - {"acosh|d", bi_acosh, -1}, - {"atanh|d", bi_atanh, -1}, + {"sin|f", bi_sinf, -1, 1, {p(float)}}, + {"cos|f", bi_cosf, -1, 1, {p(float)}}, + {"tan|f", bi_tanf, -1, 1, {p(float)}}, + {"asin|f", bi_asinf, -1, 1, {p(float)}}, + {"acos|f", bi_acosf, -1, 1, {p(float)}}, + {"atan|f", bi_atanf, -1, 1, {p(float)}}, + {"atan2|ff",bi_atan2f, -1, 2, {p(float), p(float)}}, + {"exp|f", bi_expf, -1, 1, {p(float)}}, + {"log|f", bi_logf, -1, 1, {p(float)}}, + {"log2|f", bi_log2f, -1, 1, {p(float)}}, + {"log10|f", bi_log10f, -1, 1, {p(float)}}, + {"pow|ff", bi_powf, -1, 2, {p(float), p(float)}}, + {"sqrt|f", bi_sqrtf, -1, 1, {p(float)}}, + {"cbrt|f", bi_cbrtf, -1, 1, {p(float)}}, + {"hypot|ff",bi_hypotf, -1, 2, {p(float), p(float)}}, + {"sinh|f", bi_sinhf, -1, 1, {p(float)}}, + {"cosh|f", bi_coshf, -1, 1, {p(float)}}, + {"tanh|f", bi_tanhf, -1, 1, {p(float)}}, + {"asinh|f", bi_asinhf, -1, 1, {p(float)}}, + {"acosh|f", bi_acoshf, -1, 1, {p(float)}}, + {"atanh|f", bi_atanhf, -1, 1, {p(float)}}, + {"floor|d", bi_floor, -1, 1, {p(double)}}, // float version in pr_cmds + {"ceil|d", bi_ceil, -1, 1, {p(double)}}, // float version in pr_cmds + {"fabs|d", bi_fabs, -1, 1, {p(double)}}, // float version in pr_cmds + {"sin|d", bi_sin, -1, 1, {p(double)}}, + {"cos|d", bi_cos, -1, 1, {p(double)}}, + {"tan|d", bi_tan, -1, 1, {p(double)}}, + {"asin|d", bi_asin, -1, 1, {p(double)}}, + {"acos|d", bi_acos, -1, 1, {p(double)}}, + {"atan|d", bi_atan, -1, 1, {p(double)}}, + {"atan2|dd",bi_atan2, -1, 2, {p(double), p(double)}}, + {"exp|d", bi_exp, -1, 1, {p(double)}}, + {"log|d", bi_log, -1, 1, {p(double)}}, + {"log2|d", bi_log2, -1, 1, {p(double)}}, + {"log10|d", bi_log10, -1, 1, {p(double)}}, + {"pow|dd", bi_pow, -1, 2, {p(double), p(double)}}, + {"sqrt|d", bi_sqrt, -1, 1, {p(double)}}, + {"cbrt|d", bi_cbrt, -1, 1, {p(double)}}, + {"hypot|dd",bi_hypot, -1, 2, {p(double), p(double)}}, + {"sinh|d", bi_sinh, -1, 1, {p(double)}}, + {"cosh|d", bi_cosh, -1, 1, {p(double)}}, + {"tanh|d", bi_tanh, -1, 1, {p(double)}}, + {"asinh|d", bi_asinh, -1, 1, {p(double)}}, + {"acosh|d", bi_acosh, -1, 1, {p(double)}}, + {"atanh|d", bi_atanh, -1, 1, {p(double)}}, {0} }; diff --git a/libs/ruamoko/rua_mersenne.c b/libs/ruamoko/rua_mersenne.c index 6c503914f..200b56785 100644 --- a/libs/ruamoko/rua_mersenne.c +++ b/libs/ruamoko/rua_mersenne.c @@ -145,14 +145,15 @@ bi_mtwist_clear (progs_t *pr, void *data) state_reset (res); } -#define bi(x) {#x, bi_##x, -1} +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - bi(mtwist_new), - bi(mtwist_delete), - bi(mtwist_seed), - bi(mtwist_rand), - bi(mtwist_rand_0_1), - bi(mtwist_rand_m1_1), + bi(mtwist_new, 1, p(int)), + bi(mtwist_delete, 1, p(ptr)), + bi(mtwist_seed, 2, p(ptr), p(int)), + bi(mtwist_rand, 1, p(ptr)), + bi(mtwist_rand_0_1, 1, p(ptr)), + bi(mtwist_rand_m1_1, 1, p(ptr)), {0} }; diff --git a/libs/ruamoko/rua_msgbuf.c b/libs/ruamoko/rua_msgbuf.c index e16525053..5d28bf53c 100644 --- a/libs/ruamoko/rua_msgbuf.c +++ b/libs/ruamoko/rua_msgbuf.c @@ -396,46 +396,49 @@ bi_MsgBuf_ReadUTF8 (progs_t *pr) R_INT (pr) = MSG_ReadUTF8 (&mb->msg); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"MsgBuf_New", bi_MsgBuf_New, -1}, - {"MsgBuf_Delete", bi_MsgBuf_Delete, -1}, - {"MsgBuf_FromFile", bi_MsgBuf_FromFile, -1}, - {"MsgBuf_MaxSize", bi_MsgBuf_MaxSize, -1}, - {"MsgBuf_CurSize", bi_MsgBuf_CurSize, -1}, - {"MsgBuf_ReadCount", bi_MsgBuf_ReadCount, -1}, - {"MsgBuf_DataPtr", bi_MsgBuf_DataPtr, -1}, + bi(MsgBuf_New, 1, p(int)), + bi(MsgBuf_Delete, 1, p(ptr)), + bi(MsgBuf_FromFile, 2, p(ptr), p(ptr)), + bi(MsgBuf_MaxSize, 1, p(ptr)), + bi(MsgBuf_CurSize, 1, p(ptr)), + bi(MsgBuf_ReadCount, 1, p(ptr)), + bi(MsgBuf_DataPtr, 1, p(ptr)), - {"MsgBuf_Clear", bi_MsgBuf_Clear, -1}, - {"MsgBuf_WriteByte", bi_MsgBuf_WriteByte, -1}, - {"MsgBuf_WriteShort", bi_MsgBuf_WriteShort, -1}, - {"MsgBuf_WriteLong", bi_MsgBuf_WriteLong, -1}, - {"MsgBuf_WriteFloat", bi_MsgBuf_WriteFloat, -1}, - {"MsgBuf_WriteString", bi_MsgBuf_WriteString, -1}, -// {"MsgBuf_WriteBytes", bi_MsgBuf_WriteBytes, -1}, - {"MsgBuf_WriteCoord", bi_MsgBuf_WriteCoord, -1}, - {"MsgBuf_WriteCoordV", bi_MsgBuf_WriteCoordV, -1}, - {"MsgBuf_WriteCoordAngleV", bi_MsgBuf_WriteCoordAngleV, -1}, - {"MsgBuf_WriteAngle", bi_MsgBuf_WriteAngle, -1}, - {"MsgBuf_WriteAngleV", bi_MsgBuf_WriteAngleV, -1}, - {"MsgBuf_WriteAngle16", bi_MsgBuf_WriteAngle16, -1}, - {"MsgBuf_WriteAngle16V", bi_MsgBuf_WriteAngle16V, -1}, - {"MsgBuf_WriteUTF8", bi_MsgBuf_WriteUTF8, -1}, + bi(MsgBuf_Clear, 1, p(ptr)), + bi(MsgBuf_WriteByte, 2, p(ptr), p(int)), + bi(MsgBuf_WriteShort, 2, p(ptr), p(int)), + bi(MsgBuf_WriteLong, 2, p(ptr), p(int)), + bi(MsgBuf_WriteFloat, 2, p(ptr), p(float)), + bi(MsgBuf_WriteString, 2, p(ptr), p(string)), +// bi(MsgBuf_WriteBytes, _, _), + bi(MsgBuf_WriteCoord, 2, p(ptr), p(float)), + bi(MsgBuf_WriteCoordV, 2, p(ptr), p(vector)), + bi(MsgBuf_WriteCoordAngleV, 2, p(ptr), p(vector)), + bi(MsgBuf_WriteAngle, 2, p(ptr), p(float)), + bi(MsgBuf_WriteAngleV, 2, p(ptr), p(vector)), + bi(MsgBuf_WriteAngle16, 2, p(ptr), p(float)), + bi(MsgBuf_WriteAngle16V, 2, p(ptr), p(vector)), + bi(MsgBuf_WriteUTF8, 2, p(ptr), p(int)), - {"MsgBuf_BeginReading", bi_MsgBuf_BeginReading, -1}, - {"MsgBuf_ReadByte", bi_MsgBuf_ReadByte, -1}, - {"MsgBuf_ReadShort", bi_MsgBuf_ReadShort, -1}, - {"MsgBuf_ReadLong", bi_MsgBuf_ReadLong, -1}, - {"MsgBuf_ReadFloat", bi_MsgBuf_ReadFloat, -1}, - {"MsgBuf_ReadString", bi_MsgBuf_ReadString, -1}, -// {"MsgBuf_ReadBytes", bi_MsgBuf_ReadBytes, -1}, - {"MsgBuf_ReadCoord", bi_MsgBuf_ReadCoord, -1}, - {"MsgBuf_ReadCoordV", bi_MsgBuf_ReadCoordV, -1}, - {"MsgBuf_ReadCoordAngleV", bi_MsgBuf_ReadCoordAngleV, -1}, - {"MsgBuf_ReadAngle", bi_MsgBuf_ReadAngle, -1}, - {"MsgBuf_ReadAngleV", bi_MsgBuf_ReadAngleV, -1}, - {"MsgBuf_ReadAngle16", bi_MsgBuf_ReadAngle16, -1}, - {"MsgBuf_ReadAngle16V", bi_MsgBuf_ReadAngle16V, -1}, - {"MsgBuf_ReadUTF8", bi_MsgBuf_ReadUTF8, -1}, + bi(MsgBuf_BeginReading, 1, p(ptr)), + bi(MsgBuf_ReadByte, 1, p(ptr)), + bi(MsgBuf_ReadShort, 1, p(ptr)), + bi(MsgBuf_ReadLong, 1, p(ptr)), + bi(MsgBuf_ReadFloat, 1, p(ptr)), + bi(MsgBuf_ReadString, 1, p(ptr)), +// bi(MsgBuf_ReadBytes, _, _), + bi(MsgBuf_ReadCoord, 1, p(ptr)), + bi(MsgBuf_ReadCoordV, 1, p(ptr)), + bi(MsgBuf_ReadCoordAngleV, 2, p(ptr), p(ptr)), + bi(MsgBuf_ReadAngle, 1, p(ptr)), + bi(MsgBuf_ReadAngleV, 1, p(ptr)), + bi(MsgBuf_ReadAngle16, 1, p(ptr)), + bi(MsgBuf_ReadAngle16V, 1, p(ptr)), + bi(MsgBuf_ReadUTF8, 1, p(ptr)), {0} }; diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index 10a5e165d..819f9c3c8 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -2078,73 +2078,76 @@ rua_PR_FindGlobal (progs_t *pr) //==================================================================== +#define bi(x,np,params...) {#x, rua_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t obj_methods [] = { - {"__obj_exec_class", rua___obj_exec_class, -1}, - {"__obj_forward", rua___obj_forward, -1}, - {"__obj_responds_to", rua___obj_responds_to, -1}, + bi(__obj_exec_class, 1, p(ptr)), + bi(__obj_forward, -3, p(ptr), p(ptr)), + bi(__obj_responds_to, 2, p(ptr), p(ptr)), - {"obj_error", rua_obj_error, -1}, - {"obj_verror", rua_obj_verror, -1}, - {"obj_set_error_handler", rua_obj_set_error_handler, -1}, - {"obj_msg_lookup", rua_obj_msg_lookup, -1}, - {"obj_msg_lookup_super", rua_obj_msg_lookup_super, -1}, - {"obj_msg_sendv", rua_obj_msg_sendv, -1}, - {"obj_increment_retaincount", rua_obj_increment_retaincount, -1}, - {"obj_decrement_retaincount", rua_obj_decrement_retaincount, -1}, - {"obj_get_retaincount", rua_obj_get_retaincount, -1}, - {"obj_malloc", rua_obj_malloc, -1}, - {"obj_atomic_malloc", rua_obj_atomic_malloc, -1}, - {"obj_valloc", rua_obj_valloc, -1}, - {"obj_realloc", rua_obj_realloc, -1}, - {"obj_calloc", rua_obj_calloc, -1}, - {"obj_free", rua_obj_free, -1}, - {"obj_get_uninstalled_dtable", rua_obj_get_uninstalled_dtable, -1}, - {"obj_msgSend", rua_obj_msgSend, -1}, - {"obj_msgSend_super", rua_obj_msgSend_super, -1}, + bi(obj_error, -4, p(ptr), p(int), p(string)), + bi(obj_verror, 4, p(ptr), p(int), p(string), P(1, 2)), + bi(obj_set_error_handler, 1, p(func)), + bi(obj_msg_lookup, 2, p(ptr), p(ptr)), + bi(obj_msg_lookup_super, 2, p(ptr), p(ptr)), + bi(obj_msg_sendv, 3, p(ptr), p(ptr), P(1, 2)), + bi(obj_increment_retaincount, 1, p(ptr)), + bi(obj_decrement_retaincount, 1, p(ptr)), + bi(obj_get_retaincount, 1, p(ptr)), + bi(obj_malloc, 1, p(int)), + bi(obj_atomic_malloc, 1, p(int)), + bi(obj_valloc, 1, p(int)), + bi(obj_realloc, 2, p(ptr), p(int)), + bi(obj_calloc, 2, p(int), p(int)), + bi(obj_free, 1, p(ptr)), + bi(obj_get_uninstalled_dtable, 0), + bi(obj_msgSend, 2, p(ptr), p(ptr)),//magic + bi(obj_msgSend_super, 2, p(ptr), p(ptr)),//magic - {"obj_get_class", rua_obj_get_class, -1}, - {"obj_lookup_class", rua_obj_lookup_class, -1}, - {"obj_next_class", rua_obj_next_class, -1}, + bi(obj_get_class, 1, p(string)), + bi(obj_lookup_class, 1, p(string)), + bi(obj_next_class, 1, p(ptr)), - {"sel_get_name", rua_sel_get_name, -1}, - {"sel_get_type", rua_sel_get_type, -1}, - {"sel_get_uid", rua_sel_get_uid, -1}, - {"sel_register_name", rua_sel_register_name, -1}, - {"sel_is_mapped", rua_sel_is_mapped, -1}, + bi(sel_get_name, 1, p(ptr)), + bi(sel_get_type, 1, p(ptr)), + bi(sel_get_uid, 1, p(string)), + bi(sel_register_name, 1, p(string)), + bi(sel_is_mapped, 1, p(ptr)), - {"class_get_class_method", rua_class_get_class_method, -1}, - {"class_get_instance_method", rua_class_get_instance_method, -1}, - {"class_pose_as", rua_class_pose_as, -1}, - {"class_create_instance", rua_class_create_instance, -1}, - {"class_get_class_name", rua_class_get_class_name, -1}, - {"class_get_instance_size", rua_class_get_instance_size, -1}, - {"class_get_meta_class", rua_class_get_meta_class, -1}, - {"class_get_super_class", rua_class_get_super_class, -1}, - {"class_get_version", rua_class_get_version, -1}, - {"class_is_class", rua_class_is_class, -1}, - {"class_is_meta_class", rua_class_is_meta_class, -1}, - {"class_set_version", rua_class_set_version, -1}, - {"class_get_gc_object_type", rua_class_get_gc_object_type, -1}, - {"class_ivar_set_gcinvisible", rua_class_ivar_set_gcinvisible, -1}, + bi(class_get_class_method, 2, p(ptr), p(ptr)), + bi(class_get_instance_method, 2, p(ptr), p(ptr)), + bi(class_pose_as, 2, p(ptr), p(ptr)), + bi(class_create_instance, 1, p(ptr)), + bi(class_get_class_name, 1, p(ptr)), + bi(class_get_instance_size, 1, p(ptr)), + bi(class_get_meta_class, 1, p(ptr)), + bi(class_get_super_class, 1, p(ptr)), + bi(class_get_version, 1, p(ptr)), + bi(class_is_class, 1, p(ptr)), + bi(class_is_meta_class, 1, p(ptr)), + bi(class_set_version, 2, p(ptr), p(int)), + bi(class_get_gc_object_type, 1, p(ptr)), + bi(class_ivar_set_gcinvisible, 3, p(ptr), p(string), p(int)), - {"method_get_imp", rua_method_get_imp, -1}, - {"get_imp", rua_get_imp, -1}, + bi(method_get_imp, 1, p(ptr)), + bi(get_imp, 1, p(ptr), p(ptr)), - {"object_copy", rua_object_copy, -1}, - {"object_dispose", rua_object_dispose, -1}, - {"object_get_class", rua_object_get_class, -1}, - {"object_get_class_name", rua_object_get_class_name, -1}, - {"object_get_meta_class", rua_object_get_meta_class, -1}, - {"object_get_super_class", rua_object_get_super_class, -1}, - {"object_is_class", rua_object_is_class, -1}, - {"object_is_instance", rua_object_is_instance, -1}, - {"object_is_meta_class", rua_object_is_meta_class, -1}, + bi(object_copy, 1, p(ptr)), + bi(object_dispose, 1, p(ptr)), + bi(object_get_class, 1, p(ptr)), + bi(object_get_class_name, 1, p(ptr)), + bi(object_get_meta_class, 1, p(ptr)), + bi(object_get_super_class, 1, p(ptr)), + bi(object_is_class, 1, p(ptr)), + bi(object_is_instance, 1, p(ptr)), + bi(object_is_meta_class, 1, p(ptr)), - {"_i_Object__hash", rua__i_Object__hash, -1}, - {"_i_Object_error_error_", rua__i_Object_error_error_, -1}, - {"_c_Object__conformsToProtocol_", rua__c_Object__conformsToProtocol_, -1}, + bi(_i_Object__hash, 2, p(ptr), p(ptr)), + bi(_i_Object_error_error_, -4, p(ptr), p(ptr), p(string)), + bi(_c_Object__conformsToProtocol_, 3, p(ptr), p(ptr), p(ptr)), - {"PR_FindGlobal", rua_PR_FindGlobal, -1},//FIXME + bi(PR_FindGlobal, 1, p(string)),//FIXME {0} }; diff --git a/libs/ruamoko/rua_plist.c b/libs/ruamoko/rua_plist.c index 2899eec5f..1f27c6b74 100644 --- a/libs/ruamoko/rua_plist.c +++ b/libs/ruamoko/rua_plist.c @@ -444,28 +444,30 @@ plist_compare (const void *k1, const void *k2, void *unused) return pl1->plitem == pl2->plitem; } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"PL_GetFromFile", bi_PL_GetFromFile, -1}, - {"PL_GetPropertyList", bi_PL_GetPropertyList, -1}, - {"PL_WritePropertyList", bi_PL_WritePropertyList, -1}, - {"PL_Type", bi_PL_Type, -1}, - {"PL_Line", bi_PL_Line, -1}, - {"PL_String", bi_PL_String, -1}, - {"PL_ObjectForKey", bi_PL_ObjectForKey, -1}, - {"PL_RemoveObjectForKey", bi_PL_RemoveObjectForKey, -1}, - {"PL_ObjectAtIndex", bi_PL_ObjectAtIndex, -1}, - {"PL_D_AllKeys", bi_PL_D_AllKeys, -1}, - {"PL_D_NumKeys", bi_PL_D_NumKeys, -1}, - {"PL_D_AddObject", bi_PL_D_AddObject, -1}, - {"PL_A_AddObject", bi_PL_A_AddObject, -1}, - {"PL_A_NumObjects", bi_PL_A_NumObjects, -1}, - {"PL_A_InsertObjectAtIndex", bi_PL_A_InsertObjectAtIndex, -1}, - {"PL_RemoveObjectAtIndex", bi_PL_RemoveObjectAtIndex, -1}, - {"PL_NewDictionary", bi_PL_NewDictionary, -1}, - {"PL_NewArray", bi_PL_NewArray, -1}, - {"PL_NewData", bi_PL_NewData, -1}, - {"PL_NewString", bi_PL_NewString, -1}, - {"PL_Free", bi_PL_Free, -1}, + bi(PL_GetFromFile, 1, p(ptr)), + bi(PL_GetPropertyList, 1, p(string)), + bi(PL_WritePropertyList, 1, p(ptr)), + bi(PL_Type, 1, p(ptr)), + bi(PL_Line, 1, p(ptr)), + bi(PL_String, 1, p(ptr)), + bi(PL_ObjectForKey, 2, p(ptr), p(string)), + bi(PL_RemoveObjectForKey, 2, p(ptr), p(string)), + bi(PL_ObjectAtIndex, 2, p(ptr), p(int)), + bi(PL_D_AllKeys, 1, p(ptr)), + bi(PL_D_NumKeys, 1, p(ptr)), + bi(PL_D_AddObject, 3, p(ptr), p(string), p(ptr)), + bi(PL_A_AddObject, 2, p(ptr), p(ptr)), + bi(PL_A_NumObjects, 1, p(ptr)), + bi(PL_A_InsertObjectAtIndex, 3, p(ptr), p(ptr), p(int)), + bi(PL_RemoveObjectAtIndex, 2, p(ptr), p(int)), + bi(PL_NewDictionary, 0), + bi(PL_NewArray, 0), + bi(PL_NewData, 2, p(ptr), p(int)), + bi(PL_NewString, 1, p(string)), + bi(PL_Free, 1, p(ptr)), {0} }; diff --git a/libs/ruamoko/rua_qfile.c b/libs/ruamoko/rua_qfile.c index 55e36acd1..afe23a4e7 100644 --- a/libs/ruamoko/rua_qfile.c +++ b/libs/ruamoko/rua_qfile.c @@ -346,35 +346,40 @@ bi_Qfilesize (progs_t *pr) R_INT (pr) = Qfilesize (h->file); } +#define bi(x,np,params...) {#x, secured, -1, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t secure_builtins[] = { - {"Qrename", secured, -1}, - {"Qremove", secured, -1}, - {"Qopen", secured, -1}, + bi(Qrename, 2, p(string), p(string)), + bi(Qremove, 1, p(string)), + bi(Qopen, 2, p(string), p(string)), {0} }; +#undef bi +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} static builtin_t insecure_builtins[] = { - {"Qrename", bi_Qrename, -1}, - {"Qremove", bi_Qremove, -1}, - {"Qopen", bi_Qopen, -1}, + bi(Qrename, 2, p(string), p(string)), + bi(Qremove, 1, p(string)), + bi(Qopen, 2, p(string), p(string)), {0} }; static builtin_t builtins[] = { - {"Qclose", bi_Qclose, -1}, - {"Qgetline", bi_Qgetline, -1}, - {"Qreadstring", bi_Qreadstring, -1}, - {"Qread", bi_Qread, -1}, - {"Qwrite", bi_Qwrite, -1}, - {"Qputs", bi_Qputs, -1}, -// {"Qgets", bi_Qgets, -1}, - {"Qgetc", bi_Qgetc, -1}, - {"Qputc", bi_Qputc, -1}, - {"Qseek", bi_Qseek, -1}, - {"Qtell", bi_Qtell, -1}, - {"Qflush", bi_Qflush, -1}, - {"Qeof", bi_Qeof, -1}, - {"Qfilesize", bi_Qfilesize, -1}, + bi(Qclose, 1, p(ptr)), + bi(Qgetline, 1, p(ptr)), + bi(Qreadstring, 2, p(ptr), p(int)), + bi(Qread, 3, p(ptr), p(ptr), p(int)), + bi(Qwrite, 3, p(ptr), p(ptr), p(int)), + bi(Qputs, 2, p(ptr), p(string)), +// bi(Qgets, _, _), + bi(Qgetc, 1, p(ptr)), + bi(Qputc, 2, p(ptr), p(int)), + bi(Qseek, 3, p(ptr), p(int), p(int)), + bi(Qtell, 1, p(ptr)), + bi(Qflush, 1, p(ptr)), + bi(Qeof, 1, p(ptr)), + bi(Qfilesize, 1, p(ptr)), {0} }; diff --git a/libs/ruamoko/rua_qfs.c b/libs/ruamoko/rua_qfs.c index c29dc3ec8..9c34d6abe 100644 --- a/libs/ruamoko/rua_qfs.c +++ b/libs/ruamoko/rua_qfs.c @@ -188,16 +188,18 @@ bi_QFS_GetDirectory (progs_t *pr) RETURN_STRING (pr, qfs_gamedir->dir.def); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"QFS_Open", bi_QFS_Open, -1}, - {"QFS_WOpen", bi_QFS_WOpen, -1}, - {"QFS_Rename", bi_QFS_Rename, -1}, - {"QFS_LoadFile", bi_QFS_LoadFile, -1}, - {"QFS_OpenFile", bi_QFS_OpenFile, -1}, - {"QFS_WriteFile", bi_QFS_WriteFile, -1}, - {"QFS_Filelist", bi_QFS_Filelist, -1}, - {"QFS_FilelistFree", bi_QFS_FilelistFree, -1}, - {"QFS_GetDirectory", bi_QFS_GetDirectory, -1}, + bi(QFS_Open, 2, p(string), p(string)), + bi(QFS_WOpen, 2, p(string), p(int)), + bi(QFS_Rename, 2, p(string), p(string)), + bi(QFS_LoadFile, 1, p(string)), + bi(QFS_OpenFile, 1, p(string)), + bi(QFS_WriteFile, 3, p(string), p(ptr), p(int)), + bi(QFS_Filelist, 3, p(string), p(string), p(int)), + bi(QFS_FilelistFree, 1, p(ptr)), + bi(QFS_GetDirectory, 0), {0} }; diff --git a/libs/ruamoko/rua_runtime.c b/libs/ruamoko/rua_runtime.c index 3fe21db51..54b67b205 100644 --- a/libs/ruamoko/rua_runtime.c +++ b/libs/ruamoko/rua_runtime.c @@ -69,8 +69,11 @@ bi_va_copy (progs_t *pr) R_PACKED (pr, pr_va_list_t).list = PR_SetPointer (pr, dst_list); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"va_copy", bi_va_copy, -1}, + bi(va_copy, 1, P(1, 2)), {0} }; diff --git a/libs/ruamoko/rua_script.c b/libs/ruamoko/rua_script.c index cfb9a7e9a..4a90a99e3 100644 --- a/libs/ruamoko/rua_script.c +++ b/libs/ruamoko/rua_script.c @@ -187,15 +187,17 @@ bi_Script_NoQuoteLines (progs_t *pr) script->script.no_quote_lines = P_INT (pr, 1); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"Script_New", bi_Script_New, -1}, - {"Script_Delete", bi_Script_Delete, -1}, - {"Script_Start", bi_Script_Start, -1}, - {"Script_TokenAvailable", bi_Script_TokenAvailable, -1}, - {"Script_GetToken", bi_Script_GetToken, -1}, - {"Script_UngetToken", bi_Script_UngetToken, -1}, - {"Script_Error", bi_Script_Error, -1}, - {"Script_NoQuoteLines", bi_Script_NoQuoteLines, -1}, + bi(Script_New, 0), + bi(Script_Delete, 1, p(ptr)), + bi(Script_Start, 3, p(ptr), p(string), p(string)), + bi(Script_TokenAvailable, 2, p(ptr), p(int)), + bi(Script_GetToken, 2, p(ptr), p(int)), + bi(Script_UngetToken, 1, p(ptr)), + bi(Script_Error, 1, p(ptr)), + bi(Script_NoQuoteLines, 1, p(ptr)), {0} }; diff --git a/libs/ruamoko/rua_set.c b/libs/ruamoko/rua_set.c index 632a6a10a..647f7716b 100644 --- a/libs/ruamoko/rua_set.c +++ b/libs/ruamoko/rua_set.c @@ -178,6 +178,15 @@ bi_set_del_iter (progs_t *pr) del_set_iter (pr, set_iter); } +static void +bi_set_iter_element (progs_t *pr) +{ + bi_set_iter_t *set_iter = get_set_iter (pr, __FUNCTION__, P_INT (pr, 0)); + + R_INT (pr) = set_iter->iter->element; + +} + static void bi_set_new (progs_t *pr) { @@ -421,7 +430,7 @@ bi_set_as_string (progs_t *pr) } static void -bi_i_SetIterator__element (progs_t *pr) +bi__i_SetIterator__element (progs_t *pr) { pr_set_iter_t *iter_obj = &P_STRUCT (pr, pr_set_iter_t, 0); bi_set_iter_t *set_iter = get_set_iter (pr, __FUNCTION__, iter_obj->iter); @@ -430,7 +439,7 @@ bi_i_SetIterator__element (progs_t *pr) } static void -bi_i_Set__add_ (progs_t *pr) +bi__i_Set__add_ (progs_t *pr) { pr_ptr_t set_ptr = P_POINTER (pr, 0); pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); @@ -443,7 +452,7 @@ bi_i_Set__add_ (progs_t *pr) } static void -bi_i_Set__remove_ (progs_t *pr) +bi__i_Set__remove_ (progs_t *pr) { pr_ptr_t set_ptr = P_POINTER (pr, 0); pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); @@ -456,7 +465,7 @@ bi_i_Set__remove_ (progs_t *pr) } static void -bi_i_Set__invert (progs_t *pr) +bi__i_Set__invert (progs_t *pr) { pr_ptr_t set_ptr = P_POINTER (pr, 0); pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); @@ -468,7 +477,7 @@ bi_i_Set__invert (progs_t *pr) } static void -bi_i_Set__union_ (progs_t *pr) +bi__i_Set__union_ (progs_t *pr) { pr_ptr_t dst_ptr = P_POINTER (pr, 0); pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); @@ -482,7 +491,7 @@ bi_i_Set__union_ (progs_t *pr) } static void -bi_i_Set__intersection_ (progs_t *pr) +bi__i_Set__intersection_ (progs_t *pr) { pr_ptr_t dst_ptr = P_POINTER (pr, 0); pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); @@ -496,7 +505,7 @@ bi_i_Set__intersection_ (progs_t *pr) } static void -bi_i_Set__difference_ (progs_t *pr) +bi__i_Set__difference_ (progs_t *pr) { pr_ptr_t dst_ptr = P_POINTER (pr, 0); pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); @@ -510,7 +519,7 @@ bi_i_Set__difference_ (progs_t *pr) } static void -bi_i_Set__reverse_difference_ (progs_t *pr) +bi__i_Set__reverse_difference_ (progs_t *pr) { pr_ptr_t dst_ptr = P_POINTER (pr, 0); pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); @@ -524,7 +533,7 @@ bi_i_Set__reverse_difference_ (progs_t *pr) } static void -bi_i_Set__assign_ (progs_t *pr) +bi__i_Set__assign_ (progs_t *pr) { pr_ptr_t dst_ptr = P_POINTER (pr, 0); pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); @@ -538,7 +547,7 @@ bi_i_Set__assign_ (progs_t *pr) } static void -bi_i_Set__empty (progs_t *pr) +bi__i_Set__empty (progs_t *pr) { pr_ptr_t set_ptr = P_POINTER (pr, 0); pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); @@ -550,7 +559,7 @@ bi_i_Set__empty (progs_t *pr) } static void -bi_i_Set__everything (progs_t *pr) +bi__i_Set__everything (progs_t *pr) { pr_ptr_t set_ptr = P_POINTER (pr, 0); pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); @@ -562,7 +571,7 @@ bi_i_Set__everything (progs_t *pr) } static void -bi_i_Set__is_empty (progs_t *pr) +bi__i_Set__is_empty (progs_t *pr) { pr_set_t *set_obj = &P_STRUCT (pr, pr_set_t, 0); @@ -572,7 +581,7 @@ bi_i_Set__is_empty (progs_t *pr) } static void -bi_i_Set__is_everything (progs_t *pr) +bi__i_Set__is_everything (progs_t *pr) { pr_set_t *set_obj = &P_STRUCT (pr, pr_set_t, 0); @@ -582,7 +591,7 @@ bi_i_Set__is_everything (progs_t *pr) } static void -bi_i_Set__is_disjoint_ (progs_t *pr) +bi__i_Set__is_disjoint_ (progs_t *pr) { pr_set_t *s1_obj = &P_STRUCT (pr, pr_set_t, 0); pr_set_t *s2_obj = &P_STRUCT (pr, pr_set_t, 2); @@ -594,7 +603,7 @@ bi_i_Set__is_disjoint_ (progs_t *pr) } static void -bi_i_Set__is_intersecting_ (progs_t *pr) +bi__i_Set__is_intersecting_ (progs_t *pr) { pr_set_t *s1_obj = &P_STRUCT (pr, pr_set_t, 0); pr_set_t *s2_obj = &P_STRUCT (pr, pr_set_t, 2); @@ -606,7 +615,7 @@ bi_i_Set__is_intersecting_ (progs_t *pr) } static void -bi_i_Set__is_equivalent_ (progs_t *pr) +bi__i_Set__is_equivalent_ (progs_t *pr) { pr_set_t *s1_obj = &P_STRUCT (pr, pr_set_t, 0); pr_set_t *s2_obj = &P_STRUCT (pr, pr_set_t, 2); @@ -618,7 +627,7 @@ bi_i_Set__is_equivalent_ (progs_t *pr) } static void -bi_i_Set__is_subset_ (progs_t *pr) +bi__i_Set__is_subset_ (progs_t *pr) { pr_set_t *s1_obj = &P_STRUCT (pr, pr_set_t, 0); pr_set_t *s2_obj = &P_STRUCT (pr, pr_set_t, 2); @@ -630,7 +639,7 @@ bi_i_Set__is_subset_ (progs_t *pr) } static void -bi_i_Set__is_member_ (progs_t *pr) +bi__i_Set__is_member_ (progs_t *pr) { pr_set_t *set_obj = &P_STRUCT (pr, pr_set_t, 0); @@ -641,7 +650,7 @@ bi_i_Set__is_member_ (progs_t *pr) } static void -bi_i_Set__size (progs_t *pr) +bi__i_Set__size (progs_t *pr) { pr_set_t *set_obj = &P_STRUCT (pr, pr_set_t, 0); @@ -651,7 +660,7 @@ bi_i_Set__size (progs_t *pr) } static void -bi_i_Set__as_string (progs_t *pr) +bi__i_Set__as_string (progs_t *pr) { pr_set_t *set_obj = &P_STRUCT (pr, pr_set_t, 0); @@ -677,53 +686,56 @@ res_set_clear (progs_t *pr, void *data) res_set_iter_reset (res); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"set_del_iter", bi_set_del_iter, -1}, - {"set_new", bi_set_new, -1}, - {"set_delete", bi_set_delete, -1}, - {"set_add", bi_set_add, -1}, - {"set_remove", bi_set_remove, -1}, - {"set_invert", bi_set_invert, -1}, - {"set_union", bi_set_union, -1}, - {"set_intersection", bi_set_intersection, -1}, - {"set_difference", bi_set_difference, -1}, - {"set_reverse_difference", bi_set_reverse_difference, -1}, - {"set_assign", bi_set_assign, -1}, - {"set_empty", bi_set_empty, -1}, - {"set_everything", bi_set_everything, -1}, - {"set_is_empty", bi_set_is_empty, -1}, - {"set_is_everything", bi_set_is_everything, -1}, - {"set_is_disjoint", bi_set_is_disjoint, -1}, - {"set_is_intersecting", bi_set_is_intersecting, -1}, - {"set_is_equivalent", bi_set_is_equivalent, -1}, - {"set_is_subset", bi_set_is_subset, -1}, - {"set_is_member", bi_set_is_member, -1}, - {"set_count", bi_set_count, -1}, - {"set_first", bi_set_first, -1}, - {"set_next", bi_set_next, -1}, - {"set_as_string", bi_set_as_string, -1}, + bi(set_del_iter, 1, p(ptr)), + bi(set_iter_element, 1, p(ptr)), + bi(set_new, 0), + bi(set_delete, 1, p(ptr)), + bi(set_add, 2, p(ptr), p(uint)), + bi(set_remove, 2, p(ptr), p(uint)), + bi(set_invert, 1, p(ptr)), + bi(set_union, 2, p(ptr), p(ptr)), + bi(set_intersection, 2, p(ptr), p(ptr)), + bi(set_difference, 2, p(ptr), p(ptr)), + bi(set_reverse_difference, 2, p(ptr), p(ptr)), + bi(set_assign, 2, p(ptr), p(ptr)), + bi(set_empty, 1, p(ptr)), + bi(set_everything, 1, p(ptr)), + bi(set_is_empty, 1, p(ptr)), + bi(set_is_everything, 1, p(ptr)), + bi(set_is_disjoint, 2, p(ptr), p(ptr)), + bi(set_is_intersecting, 2, p(ptr), p(ptr)), + bi(set_is_equivalent, 2, p(ptr), p(ptr)), + bi(set_is_subset, 2, p(ptr), p(ptr)), + bi(set_is_member, 2, p(ptr), p(uint)), + bi(set_count, 1, p(ptr)), + bi(set_first, 1, p(ptr)), + bi(set_next, 1, p(ptr)), + bi(set_as_string, 1, p(ptr)), - {"_i_SetIterator__element", bi_i_SetIterator__element, -1}, + bi(_i_SetIterator__element, 2, p(ptr), p(ptr)), - {"_i_Set__add_", bi_i_Set__add_, -1}, - {"_i_Set__remove_", bi_i_Set__remove_, -1}, - {"_i_Set__invert", bi_i_Set__invert, -1}, - {"_i_Set__union_", bi_i_Set__union_, -1}, - {"_i_Set__intersection_", bi_i_Set__intersection_, -1}, - {"_i_Set__difference_", bi_i_Set__difference_, -1}, - {"_i_Set__reverse_difference_", bi_i_Set__reverse_difference_, -1}, - {"_i_Set__assign_", bi_i_Set__assign_, -1}, - {"_i_Set__empty", bi_i_Set__empty, -1}, - {"_i_Set__everything", bi_i_Set__everything, -1}, - {"_i_Set__is_empty", bi_i_Set__is_empty, -1}, - {"_i_Set__is_everything", bi_i_Set__is_everything, -1}, - {"_i_Set__is_disjoint_", bi_i_Set__is_disjoint_, -1}, - {"_i_Set__is_intersecting_", bi_i_Set__is_intersecting_, -1}, - {"_i_Set__is_equivalent_", bi_i_Set__is_equivalent_, -1}, - {"_i_Set__is_subset_", bi_i_Set__is_subset_, -1}, - {"_i_Set__is_member_", bi_i_Set__is_member_, -1}, - {"_i_Set__size", bi_i_Set__size, -1}, - {"_i_Set__as_string", bi_i_Set__as_string, -1}, + bi(_i_Set__add_, 3, p(ptr), p(ptr), p(uint)), + bi(_i_Set__remove_, 3, p(ptr), p(ptr), p(uint)), + bi(_i_Set__invert, 2, p(ptr), p(ptr)), + bi(_i_Set__union_, 3, p(ptr), p(ptr), p(ptr)), + bi(_i_Set__intersection_, 3, p(ptr), p(ptr), p(ptr)), + bi(_i_Set__difference_, 3, p(ptr), p(ptr), p(ptr)), + bi(_i_Set__reverse_difference_, 3, p(ptr), p(ptr), p(ptr)), + bi(_i_Set__assign_, 3, p(ptr), p(ptr), p(ptr)), + bi(_i_Set__empty, 2, p(ptr), p(ptr)), + bi(_i_Set__everything, 2, p(ptr), p(ptr)), + bi(_i_Set__is_empty, 2, p(ptr), p(ptr)), + bi(_i_Set__is_everything, 2, p(ptr), p(ptr)), + bi(_i_Set__is_disjoint_, 3, p(ptr), p(ptr), p(ptr)), + bi(_i_Set__is_intersecting_, 3, p(ptr), p(ptr), p(ptr)), + bi(_i_Set__is_equivalent_, 3, p(ptr), p(ptr), p(ptr)), + bi(_i_Set__is_subset_, 3, p(ptr), p(ptr), p(ptr)), + bi(_i_Set__is_member_, 3, p(ptr), p(ptr), p(uint)), + bi(_i_Set__size, 2, p(ptr), p(ptr)), + bi(_i_Set__as_string, 2, p(ptr), p(ptr)), {0} }; diff --git a/libs/ruamoko/rua_stdlib.c b/libs/ruamoko/rua_stdlib.c index 2ef4d914a..19dd7bc7e 100644 --- a/libs/ruamoko/rua_stdlib.c +++ b/libs/ruamoko/rua_stdlib.c @@ -156,12 +156,15 @@ bi_prefixsumf (progs_t *pr) } } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"bsearch", bi_bsearch, -1}, - {"fbsearch", bi_fbsearch, -1}, - {"qsort", bi_qsort, -1}, - {"prefixsum|^ii", bi_prefixsumi, -1}, - {"prefixsum|^fi", bi_prefixsumf, -1}, + bi(bsearch, 4, p(ptr), p(ptr), p(int), p(int), p(func)), + bi(fbsearch, 4, p(ptr), p(ptr), p(int), p(int), p(func)), + bi(qsort, 3, p(ptr), p(int), p(int), p(func)), + {"prefixsum|^ii", bi_prefixsumi, -1, 2, {p(ptr), p(int)}}, + {"prefixsum|^fi", bi_prefixsumf, -1, 2, {p(ptr), p(int)}}, {0} }; diff --git a/libs/ruamoko/rua_string.c b/libs/ruamoko/rua_string.c index c808ae963..21006ac42 100644 --- a/libs/ruamoko/rua_string.c +++ b/libs/ruamoko/rua_string.c @@ -281,25 +281,28 @@ bi_str_upper (progs_t *pr) RETURN_STRING (pr, upper); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"strlen", bi_strlen, -1}, - {"sprintf", bi_sprintf, -1}, - {"vsprintf", bi_vsprintf, -1}, - {"str_new", bi_str_new, -1}, - {"str_free", bi_str_free, -1}, - {"str_hold", bi_str_hold, -1}, - {"str_valid", bi_str_valid, -1}, - {"str_mutable", bi_str_mutable, -1}, - {"str_copy", bi_str_copy, -1}, - {"str_cat", bi_str_cat, -1}, - {"str_clear", bi_str_clear, -1}, - {"str_mid|*i", bi_str_mid, -1}, - {"str_mid|*ii", bi_str_mid, -1}, - {"str_str", bi_str_str, -1}, - {"str_char", bi_str_char, -1}, - {"str_quote", bi_str_quote, -1}, - {"str_lower", bi_str_lower, -1}, - {"str_upper", bi_str_upper, -1}, + bi(strlen, 1, p(string)), + bi(sprintf, -2, p(string)), + bi(vsprintf, 2, p(string), P(1, 2)), + bi(str_new, 0), + bi(str_free, 1, p(string)), + bi(str_hold, 1, p(string)), + bi(str_valid, 1, p(string)), + bi(str_mutable, 1, p(string)), + bi(str_copy, 2, p(string), p(string)), + bi(str_cat, 2, p(string), p(string)), + bi(str_clear, 1, p(string)), + {"str_mid|*i", bi_str_mid, -1, 2, {p(string), p(int)}}, + {"str_mid|*ii", bi_str_mid, -1, 3, {p(string), p(int), p(int)}}, + bi(str_str, 2, p(string), p(string)), + bi(str_char, 2, p(string), p(int)), + bi(str_quote, 1, p(string)), + bi(str_lower, 1, p(string)), + bi(str_upper, 1, p(string)), {0} }; diff --git a/libs/video/renderer/r_progs.c b/libs/video/renderer/r_progs.c index c09569c56..2fbaa6e28 100644 --- a/libs/video/renderer/r_progs.c +++ b/libs/video/renderer/r_progs.c @@ -324,20 +324,24 @@ bi_draw_clear (progs_t *pr, void *data) Hash_FlushTable (res->pic_hash); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"Draw_FreePic", bi_Draw_FreePic, -1}, - {"Draw_MakePic", bi_Draw_MakePic, -1}, - {"Draw_CachePic", bi_Draw_CachePic, -1}, - {"Draw_Pic", bi_Draw_Pic, -1}, - {"Draw_Picf", bi_Draw_Picf, -1}, - {"Draw_SubPic", bi_Draw_SubPic, -1}, - {"Draw_CenterPic", bi_Draw_CenterPic, -1}, - {"Draw_Character", bi_Draw_Character, -1}, - {"Draw_String", bi_Draw_String, -1}, - {"Draw_nString", bi_Draw_nString, -1}, - {"Draw_AltString", bi_Draw_AltString, -1}, - {"Draw_Fill", bi_Draw_Fill, -1}, - {"Draw_Crosshair", bi_Draw_Crosshair, -1}, + bi(Draw_FreePic, 1, p(ptr)), + bi(Draw_MakePic, 3, p(int), p(int), p(string)), + bi(Draw_CachePic, 2, p(string), p(int)), + bi(Draw_Pic, 3, p(int), p(int), p(ptr)), + bi(Draw_Picf, 3, p(float), p(float), p(ptr)), + bi(Draw_SubPic, 7, p(int), p(int), p(ptr), + p(int), p(int), p(int), p(int)), + bi(Draw_CenterPic, 3, p(int), p(int), p(ptr)), + bi(Draw_Character, 3, p(int), p(int), p(int)), + bi(Draw_String, 3, p(int), p(int), p(string)), + bi(Draw_nString, 4, p(int), p(int), p(string), p(int)), + bi(Draw_AltString, 3, p(int), p(int), p(string)), + bi(Draw_Fill, 5, p(int), p(int), p(int), p(int), p(int)), + bi(Draw_Crosshair, 5, p(int), p(int), p(int), p(int)), {0} }; diff --git a/nq/source/sv_pr_cmds.c b/nq/source/sv_pr_cmds.c index 71a6d03f3..5c98aa5d9 100644 --- a/nq/source/sv_pr_cmds.c +++ b/nq/source/sv_pr_cmds.c @@ -731,7 +731,7 @@ PF_findradius (progs_t *pr) // entity () spawn static void -PF_Spawn (progs_t *pr) +PF_spawn (progs_t *pr) { edict_t *ed; @@ -741,7 +741,7 @@ PF_Spawn (progs_t *pr) // void (entity e) remove static void -PF_Remove (progs_t *pr) +PF_remove (progs_t *pr) { edict_t *ed; @@ -798,6 +798,7 @@ PF_precache_file (progs_t *pr) // precache_file is used only to copy files with qcc, it does nothing R_INT (pr) = P_INT (pr, 0); } +#define PF_precache_file2 PF_precache_file // void (string s) precache_sound // string (string s) precache_sound2 @@ -808,6 +809,7 @@ PF_precache_sound (progs_t *pr) "precache_sound"); R_INT (pr) = P_INT (pr, 0); } +#define PF_precache_sound2 PF_precache_sound // void (string s) precache_model // string (string s) precache_model2 @@ -821,6 +823,7 @@ PF_precache_model (progs_t *pr) sv.models[ind] = Mod_ForName (mod, true); R_INT (pr) = P_INT (pr, 0); } +#define PF_precache_model2 PF_precache_model /* PF_walkmove @@ -1474,78 +1477,83 @@ PF_checkextension (progs_t *pr) #define QF (PR_RANGE_QF << PR_RANGE_SHIFT) | +#define bi(x,n,np,params...) {#x, PF_##x, n, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"makevectors", PF_makevectors, 1}, - {"setorigin", PF_setorigin, 2}, - {"setmodel", PF_setmodel, 3}, - {"setsize", PF_setsize, 4}, + bi(makevectors, 1, 1, p(vector)), + bi(setorigin, 2, 2, p(entity), p(vector)), + bi(setmodel, 3, 2, p(entity), p(string)), + bi(setsize, 4, 3, p(entity), p(vector), p(vector)), - {"sound", PF_sound, 8}, + bi(sound, 8, 3, p(entity), p(float), p(string)), - {"error", PF_error, 10}, - {"objerror", PF_objerror, 11}, - {"spawn", PF_Spawn, 14}, - {"remove", PF_Remove, 15}, - {"traceline", PF_traceline, 16}, - {"checkclient", PF_checkclient, 17}, + bi(error, 10, -1), // (...) + bi(objerror, 11, -1), // (...) + bi(spawn, 14, 0), // (void) + bi(remove, 15, 1, p(entity)), + bi(traceline, 16, 3, p(vector), p(vector), p(float)), + bi(checkclient, 17, 0), // (void) - {"precache_sound", PF_precache_sound, 19}, - {"precache_model", PF_precache_model, 20}, - {"stuffcmd", PF_stuffcmd, 21}, - {"findradius", PF_findradius, 22}, - {"bprint", PF_bprint, 23}, - {"sprint", PF_sprint, 24}, + bi(precache_sound, 19, 1, p(string)), + bi(precache_model, 20, 1, p(string)), + bi(stuffcmd, 21, 2, p(entity), p(string)), + bi(findradius, 22, 2, p(vector), p(float)), + bi(bprint, 23, -1), // (...) + bi(sprint, 24, -2, p(entity)), // (entity, string...) - {"walkmove", PF_walkmove, 32}, + bi(walkmove, 32, 2, p(float), p(float)), - {"droptofloor", PF_droptofloor, 34}, - {"lightstyle", PF_lightstyle, 35}, + bi(droptofloor, 34, 0), // (void) + bi(lightstyle, 35, 2, p(float), p(string)), - {"checkbottom", PF_checkbottom, 40}, - {"pointcontents", PF_pointcontents, 41}, + bi(checkbottom, 40, 1, p(entity)), + bi(pointcontents, 41, 1, p(vector)), - {"aim", PF_aim, 44}, + bi(aim, 44, 2, p(entity), p(float)), - {"localcmd", PF_localcmd, 46}, + bi(localcmd, 46, 1, p(string)), - {"particle", PF_particle, 48}, - {"changeyaw", PF_changeyaw, 49}, + bi(particle, 48, 4, p(vector), p(vector), p(float), p(float)), + bi(changeyaw, 49, 0), // (void) - {"writebyte", PF_WriteByte, 52}, - {"WriteBytes", PF_WriteBytes, -1}, - {"writechar", PF_WriteChar, 53}, - {"writeshort", PF_WriteShort, 54}, - {"writelong", PF_WriteLong, 55}, - {"writecoord", PF_WriteCoord, 56}, - {"writeangle", PF_WriteAngle, 57}, - {"WriteCoordV", PF_WriteCoordV, -1}, - {"WriteAngleV", PF_WriteAngleV, -1}, - {"writestring", PF_WriteString, 58}, - {"writeentity", PF_WriteEntity, 59}, + bi(WriteByte, 52, 2, p(float), p(float)), + bi(WriteBytes, -1, -2, p(float)), // (float, float...) + bi(WriteChar, 53, 2, p(float), p(float)), + bi(WriteShort, 54, 2, p(float), p(float)), + bi(WriteLong, 55, 2, p(float), p(float)), + bi(WriteCoord, 56, 2, p(float), p(float)), + bi(WriteAngle, 57, 2, p(float), p(float)), + bi(WriteCoordV, -1, 2, p(float), p(vector)), + bi(WriteAngleV, -1, 2, p(float), p(vector)), + bi(WriteString, 58, 2, p(float), p(string)), + bi(WriteEntity, 59, 2, p(float), p(entity)), +#define PF_movetogoal SV_MoveToGoal + bi(movetogoal, 67, 0), // (void) +#undef PF_movetogoal + bi(precache_file, 68, 1, p(string)), + bi(makestatic, 69, 1, p(entity)), + bi(changelevel, 70, 1, p(string)), - {"movetogoal", SV_MoveToGoal, 67}, - {"precache_file", PF_precache_file, 68}, - {"makestatic", PF_makestatic, 69}, - {"changelevel", PF_changelevel, 70}, - - {"centerprint", PF_centerprint, 73}, - {"ambientsound", PF_ambientsound, 74}, - {"precache_model2", PF_precache_model, 75}, - {"precache_sound2", PF_precache_sound, 76}, - {"precache_file2", PF_precache_file, 77}, - {"setspawnparms", PF_setspawnparms, 78}, - - {"testentitypos", PF_testentitypos, QF 92}, - {"hullpointcontents", PF_hullpointcontents, QF 93}, - {"getboxbounds", PF_getboxbounds, QF 94}, - {"getboxhull", PF_getboxhull, QF 95}, - {"freeboxhull", PF_freeboxhull, QF 96}, - {"rotate_bbox", PF_rotate_bbox, QF 97}, - {"tracebox", PF_tracebox, QF 98}, - {"checkextension", PF_checkextension, QF 99}, - - {"EntityParseFunction", ED_EntityParseFunction, -1}, + bi(centerprint, 73, -1), // (...) + bi(ambientsound, 74, 4, p(vector), p(string), p(float), p(float)), + bi(precache_model2, 75, 1, p(string)), + bi(precache_sound2, 76, 1, p(string)), + bi(precache_file2, 77, 1, p(string)), + bi(setspawnparms, 78, 1, p(entity)), + bi(testentitypos, QF 92, 1, p(entity)), + bi(hullpointcontents, QF 93, 2, p(entity), p(vector)), + bi(getboxbounds, QF 94, 2, p(int), p(int)), + bi(getboxhull, QF 95, 0), // (void) + bi(freeboxhull, QF 96, 1, p(int)), + bi(rotate_bbox, QF 97, 6, p(int), p(vector), p(vector), p(vector), + p(vector), p(vector)), + bi(tracebox, QF 98, 6, p(vector), p(vector), p(vector), p(vector), + p(float), p(entity)), + bi(checkextension, QF 99, -1, {}), //FIXME correct params? +#define PF_EntityParseFunction ED_EntityParseFunction + bi(EntityParseFunction, -1, 1, p(func)), +#undef PF_EntityParseFunction {0} }; diff --git a/qw/source/sv_pr_cmds.c b/qw/source/sv_pr_cmds.c index d6ecf086b..fd4841d7a 100644 --- a/qw/source/sv_pr_cmds.c +++ b/qw/source/sv_pr_cmds.c @@ -684,7 +684,7 @@ PF_findradius (progs_t *pr) // entity () spawn static void -PF_Spawn (progs_t *pr) +PF_spawn (progs_t *pr) { edict_t *ed; @@ -696,7 +696,7 @@ cvar_t *pr_double_remove; // void (entity e) remove static void -PF_Remove (progs_t *pr) +PF_remove (progs_t *pr) { edict_t *ed; @@ -767,6 +767,7 @@ PF_precache_file (progs_t *pr) // precache_file is used only to copy files with qcc, it does nothing R_INT (pr) = P_INT (pr, 0); } +#define PF_precache_file2 PF_precache_file // void (string s) precache_sound // string (string s) precache_sound2 @@ -777,6 +778,7 @@ PF_precache_sound (progs_t *pr) "precache_sound"); R_INT (pr) = P_INT (pr, 0); } +#define PF_precache_sound2 PF_precache_sound // void (string s) precache_model // string (string s) precache_model2 @@ -787,6 +789,7 @@ PF_precache_model (progs_t *pr) "precache_model"); R_INT (pr) = P_INT (pr, 0); } +#define PF_precache_model2 PF_precache_model /* PF_walkmove @@ -1639,7 +1642,7 @@ PF_testentitypos (progs_t *pr) #define MAX_PF_HULLS 64 // FIXME make dynamic? clip_hull_t *pf_hull_list[MAX_PF_HULLS]; -// integer (entity ent, vector point) hullpointcontents +// int (entity ent, vector point) hullpointcontents static void PF_hullpointcontents (progs_t *pr) { @@ -1655,7 +1658,7 @@ PF_hullpointcontents (progs_t *pr) R_INT (pr) = SV_HullPointContents (hull, 0, offset); } -// vector (integer hull, integer max) getboxbounds +// vector (int hull, int max) getboxbounds static void PF_getboxbounds (progs_t *pr) { @@ -1672,7 +1675,7 @@ PF_getboxbounds (progs_t *pr) } } -// integer () getboxhull +// int () getboxhull static void PF_getboxhull (progs_t *pr) { @@ -1697,7 +1700,7 @@ PF_getboxhull (progs_t *pr) } } -// void (integer hull) freeboxhull +// void (int hull) freeboxhull static void PF_freeboxhull (progs_t *pr) { @@ -1727,7 +1730,7 @@ calc_dist (vec3_t p, vec3_t n, vec3_t *offsets) return DotProduct (v, n); } -// void (integer hull, vector right, vector forward, vector up, vector mins, vector maxs) rotate_bbox +// void (int hull, vector right, vector forward, vector up, vector mins, vector maxs) rotate_bbox static void PF_rotate_bbox (progs_t *pr) { @@ -1828,7 +1831,7 @@ PF_sv_cvar (progs_t *pr) } } -// int () SV_ClientNumber +// int (entity) SV_ClientNumber // returns -1 if the entity is not a client (either not in the client range // or the entity is not in use by a client) static void @@ -1898,9 +1901,9 @@ PF_SV_SetUserinfo (progs_t *pr) SV_ExtractFromUserinfo (cl); } -// void (entity cl, integer ping) SV_SetPing +// void (entity cl, int ping) SV_SetPing static void -PR_SV_SetPing (progs_t *pr) +PF_SV_SetPing (progs_t *pr) { int entnum = P_EDICTNUM (pr, 0); client_t *cl = svs.clients + entnum - 1; @@ -1910,9 +1913,9 @@ PR_SV_SetPing (progs_t *pr) cl->ping = P_INT (pr, 1); } -// void (entity cl, float secs, vector angles, vector move, integer buttons, integer impulse) SV_UserCmd +// void (entity cl, float secs, vector angles, vector move, int buttons, int impulse) SV_UserCmd static void -PR_SV_UserCmd (progs_t *pr) +PF_SV_UserCmd (progs_t *pr) { usercmd_t ucmd; int entnum = P_EDICTNUM (pr, 0); @@ -1938,7 +1941,7 @@ PR_SV_UserCmd (progs_t *pr) // void (entity cl) SV_Spawn static void -PR_SV_Spawn (progs_t *pr) +PF_SV_Spawn (progs_t *pr) { int entnum = P_EDICTNUM (pr, 0); client_t *cl = svs.clients + entnum - 1; @@ -1951,96 +1954,106 @@ PR_SV_Spawn (progs_t *pr) #define QF (PR_RANGE_QF << PR_RANGE_SHIFT) | +#define bi(x,n,np,params...) {#x, PF_##x, n, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"makevectors", PF_makevectors, 1}, - {"setorigin", PF_setorigin, 2}, - {"setmodel", PF_setmodel, 3}, - {"setsize", PF_setsize, 4}, + bi(makevectors, 1, 1, p(vector)), + bi(setorigin, 2, 2, p(entity), p(vector)), + bi(setmodel, 3, 2, p(entity), p(string)), + bi(setsize, 4, 3, p(entity), p(vector), p(vector)), - {"sound", PF_sound, 8}, + bi(sound, 8, 3, p(entity), p(float), p(string)), - {"error", PF_error, 10}, - {"objerror", PF_objerror, 11}, - {"spawn", PF_Spawn, 14}, - {"remove", PF_Remove, 15}, - {"traceline", PF_traceline, 16}, - {"checkclient", PF_checkclient, 17}, + bi(error, 10, -1), // (...) + bi(objerror, 11, -1), // (...) + bi(spawn, 14, 0), // (void) + bi(remove, 15, 1, p(entity)), + bi(traceline, 16, 3, p(vector), p(vector), p(float)), + bi(checkclient, 17, 0), // (void) - {"precache_sound", PF_precache_sound, 19}, - {"precache_model", PF_precache_model, 20}, - {"stuffcmd", PF_stuffcmd, 21}, - {"findradius", PF_findradius, 22}, - {"bprint", PF_bprint, 23}, - {"sprint", PF_sprint, 24}, + bi(precache_sound, 19, 1, p(string)), + bi(precache_model, 20, 1, p(string)), + bi(stuffcmd, 21, 2, p(entity), p(string)), + bi(findradius, 22, 2, p(vector), p(float)), + bi(bprint, 23, -1), // (...) + bi(sprint, 24, -2, p(entity)), // (entity, string...) - {"walkmove", PF_walkmove, 32}, + bi(walkmove, 32, 2, p(float), p(float)), - {"droptofloor", PF_droptofloor, 34}, - {"lightstyle", PF_lightstyle, 35}, + bi(droptofloor, 34, 0), // (void) + bi(lightstyle, 35, 2, p(float), p(string)), - {"checkbottom", PF_checkbottom, 40}, - {"pointcontents", PF_pointcontents, 41}, + bi(checkbottom, 40, 1, p(entity)), + bi(pointcontents, 41, 1, p(vector)), - {"aim", PF_aim, 44}, + bi(aim, 44, 2, p(entity), p(float)), - {"localcmd", PF_localcmd, 46}, + bi(localcmd, 46, 1, p(string)), - {"changeyaw", PF_changeyaw, 49}, +// bi(particle, 48, 4, p(vector), p(vector), p(float), p(float)), + bi(changeyaw, 49, 0), // (void) - {"writebyte", PF_WriteByte, 52}, - {"WriteBytes", PF_WriteBytes, -1}, - {"writechar", PF_WriteChar, 53}, - {"writeshort", PF_WriteShort, 54}, - {"writelong", PF_WriteLong, 55}, - {"writecoord", PF_WriteCoord, 56}, - {"writeangle", PF_WriteAngle, 57}, - {"WriteCoordV", PF_WriteCoordV, -1}, - {"WriteAngleV", PF_WriteAngleV, -1}, - {"writestring", PF_WriteString, 58}, - {"writeentity", PF_WriteEntity, 59}, + bi(WriteByte, 52, 2, p(float), p(float)), + bi(WriteBytes, -1, -2, p(float)), // (float, float...) + bi(WriteChar, 53, 2, p(float), p(float)), + bi(WriteShort, 54, 2, p(float), p(float)), + bi(WriteLong, 55, 2, p(float), p(float)), + bi(WriteCoord, 56, 2, p(float), p(float)), + bi(WriteAngle, 57, 2, p(float), p(float)), + bi(WriteCoordV, -1, 2, p(float), p(vector)), + bi(WriteAngleV, -1, 2, p(float), p(vector)), + bi(WriteString, 58, 2, p(float), p(string)), + bi(WriteEntity, 59, 2, p(float), p(entity)), +#define PF_movetogoal SV_MoveToGoal + bi(movetogoal, 67, 0), // (void) +#undef PF_movetogoal + bi(precache_file, 68, 1, p(string)), + bi(makestatic, 69, 1, p(entity)), + bi(changelevel, 70, 1, p(string)), - {"movetogoal", SV_MoveToGoal, 67}, - {"precache_file", PF_precache_file, 68}, - {"makestatic", PF_makestatic, 69}, - {"changelevel", PF_changelevel, 70}, + bi(centerprint, 73, -1), // (...) + bi(ambientsound, 74, 4, p(vector), p(string), p(float), p(float)), + bi(precache_model2, 75, 1, p(string)), + bi(precache_sound2, 76, 1, p(string)), + bi(precache_file2, 77, 1, p(string)), + bi(setspawnparms, 78, 1, p(entity)), - {"centerprint", PF_centerprint, 73}, - {"ambientsound", PF_ambientsound, 74}, - {"precache_model2", PF_precache_model, 75}, - {"precache_sound2", PF_precache_sound, 76}, - {"precache_file2", PF_precache_file, 77}, - {"setspawnparms", PF_setspawnparms, 78}, + bi(logfrag, 79, 2, p(entity), p(entity)), + bi(infokey, 80, 2, p(entity), p(string)), + bi(multicast, 81, 2, p(vector), p(float)), - {"logfrag", PF_logfrag, 79}, - {"infokey", PF_infokey, 80}, - {"multicast", PF_multicast, 82}, + bi(testentitypos, QF 92, 1, p(entity)), + bi(hullpointcontents, QF 93, 2, p(entity), p(vector)), + bi(getboxbounds, QF 94, 2, p(int), p(int)), + bi(getboxhull, QF 95, 0), // (void) + bi(freeboxhull, QF 96, 1, p(int)), + bi(rotate_bbox, QF 97, 6, p(int), p(vector), p(vector), p(vector), + p(vector), p(vector)), + bi(tracebox, QF 98, 6, p(vector), p(vector), p(vector), p(vector), + p(float), p(entity)), + bi(checkextension, QF 99, -1, {}), //FIXME correct params? - {"testentitypos", PF_testentitypos, QF 92}, - {"hullpointcontents", PF_hullpointcontents, QF 93}, - {"getboxbounds", PF_getboxbounds, QF 94}, - {"getboxhull", PF_getboxhull, QF 95}, - {"freeboxhull", PF_freeboxhull, QF 96}, - {"rotate_bbox", PF_rotate_bbox, QF 97}, - {"tracebox", PF_tracebox, QF 98}, - {"checkextension", PF_checkextension, QF 99}, - {"setinfokey", PF_setinfokey, QF 102}, - {"cfopen", PF_cfopen, QF 103}, - {"cfclose", PF_cfclose, QF 104}, - {"cfread", PF_cfread, QF 105}, - {"cfwrite", PF_cfwrite, QF 106}, - {"cfeof", PF_cfeof, QF 107}, - {"cfquota", PF_cfquota, QF 108}, + bi(setinfokey, QF 102, 3, p(entity), p(string), p(string)), + bi(cfopen, QF 103, 2, p(string), p(string)), + bi(cfclose, QF 104, 1, p(float)), + bi(cfread, QF 105, 1, p(float)), + bi(cfwrite, QF 106, 2, p(float), p(string)), + bi(cfeof, QF 107, 1, p(float)), + bi(cfquota, QF 108, 0), // (void) - {"SV_ClientNumber", PF_SV_ClientNumber, -1}, - {"SV_AllocClient", PF_SV_AllocClient, -1}, - {"SV_FreeClient", PF_SV_FreeClient, -1}, - {"SV_SetUserinfo", PF_SV_SetUserinfo, -1}, - {"SV_SetPing", PR_SV_SetPing, -1}, - {"SV_UserCmd", PR_SV_UserCmd, -1}, - {"SV_Spawn", PR_SV_Spawn, -1}, + bi(SV_ClientNumber, -1, 1, p(entity)), + bi(SV_AllocClient, -1, 0), // (void) + bi(SV_FreeClient, -1, 1, p(entity)), + bi(SV_SetUserinfo, -1, 2, p(entity), p(string)), + bi(SV_SetPing, -1, 2, p(entity), p(int)), + bi(SV_UserCmd, -1, 6, p(entity), p(float), p(vector), p(vector), + p(int), p(int)), + bi(SV_Spawn, -1, 1, p(entity)), - {"EntityParseFunction", ED_EntityParseFunction, -1}, +#define PF_EntityParseFunction ED_EntityParseFunction + bi(EntityParseFunction, -1, 1, p(func)), +#undef PF_EntityParseFunction {0} }; diff --git a/qw/source/sv_pr_cpqw.c b/qw/source/sv_pr_cpqw.c index f331b7e32..160fb090c 100644 --- a/qw/source/sv_pr_cpqw.c +++ b/qw/source/sv_pr_cpqw.c @@ -729,7 +729,7 @@ PF_touchworld (progs_t *pr) #define TL_EVERYTHING 4 // scan for anything static void -CPQW_traceline (progs_t *pr) +PF_traceline (progs_t *pr) { float *v1, *v2; edict_t *ent; @@ -774,23 +774,27 @@ CPQW_traceline (progs_t *pr) #define CPQW (PR_RANGE_CPQW << PR_RANGE_SHIFT) | +#define bi(x,n,np,params...) {"CPCW:"#x, PF_##x, n, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"CPCW:traceline", CPQW_traceline, CPQW 16}, - {"CPQW:getuid", PF_getuid, CPQW 83}, - {"CPQW:strcat", PF_strcat, CPQW 84}, - {"CPQW:padstr", PF_padstr, CPQW 85}, - {"CPQW:colstr", PF_colstr, CPQW 86}, - {"CPQW:strcasecmp", PF_strcasecmp, CPQW 87}, - {"CPQW:strlen", PF_strlen, CPQW 88}, - {"CPQW:getclient", PF_getclient, CPQW 89}, - {"CPQW:mutedtime", PF_mutedtime, CPQW 90}, - {"CPQW:validatefile", PF_validatefile, CPQW 91}, - {"CPQW:putsaytime", PF_putsaytime, CPQW 92}, - {"CPQW:makestr", PF_makestr, CPQW 93}, - {"CPQW:delstr", PF_delstr, CPQW 94}, - {"CPQW:getwave", PF_getwave, CPQW 95}, - {"CPQW:clientsound", PF_clientsound, CPQW 96}, - {"CPQW:touchworld", PF_touchworld, CPQW 97}, + bi(traceline, CPQW 16, 3, p(vector), p(vector), p(float)), + bi(getuid, CPQW 83, 1, p(entity)), + bi(strcat, CPQW 84, 2, p(string), p(string)), + bi(padstr, CPQW 85, 2, p(string), p(float)), + bi(colstr, CPQW 86, 2, p(string), p(float)), + bi(strcasecmp, CPQW 87, 2, p(string), p(string)), + bi(strlen, CPQW 88, 1, p(string)), + bi(getclient, CPQW 89, 1, p(string)), + bi(mutedtime, CPQW 90, 1, p(entity)), + bi(validatefile, CPQW 91, 1, p(string)), + bi(putsaytime, CPQW 92, 1, p(entity)), + bi(makestr, CPQW 93, 1, p(string)), + bi(delstr, CPQW 94, 1, p(string)), + bi(getwave, CPQW 95, 7, p(float), p(float), p(float), p(float), + p(float), p(float), p(float)), + bi(clientsound, CPQW 96, 1, p(entity)), + bi(touchworld, CPQW 97, 0), {0} }; diff --git a/qw/source/sv_pr_qwe.c b/qw/source/sv_pr_qwe.c index 6c89a820b..521bb721d 100644 --- a/qw/source/sv_pr_qwe.c +++ b/qw/source/sv_pr_qwe.c @@ -480,28 +480,31 @@ PF_conprint (progs_t *pr) #define QWE (PR_RANGE_QWE << PR_RANGE_SHIFT) | +#define bi(x,n,np,params...) {"QWE:"#x, PF_##x, n, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"QWE:executecmd", PF_executecmd, QWE 83}, - {"QWE:tokanize" /* sic */, PF_tokanize, QWE 84}, - {"QWE:argc", PF_argc, QWE 85}, - {"QWE:argv", PF_argv, QWE 86}, - {"QWE:teamfield", PF_teamfield, QWE 87}, - {"QWE:substr", PF_substr, QWE 88}, - {"QWE:strcat", PF_strcat, QWE 89}, - {"QWE:strlen", PF_strlen, QWE 90}, - {"QWE:str2byte", PF_str2byte, QWE 91}, - {"QWE:str2short", PF_str2short, QWE 92}, - {"QWE:newstr", PF_newstr, QWE 93}, - {"QWE:freestr", PF_freestr, QWE 94}, - {"QWE:conprint", PF_conprint, QWE 95}, - {"QWE:readcmd", PF_readcmd, QWE 96}, - {"QWE:strcpy", PF_strcpy, QWE 97}, - {"QWE:strstr", PF_strstr, QWE 98}, - {"QWE:strncpy", PF_strncpy, QWE 99}, - {"QWE:log", PF_log, QWE 100}, - {"QWE:redirectcmd", PF_redirectcmd, QWE 101}, - {"QWE:calltimeofday", PF_calltimeofday, QWE 102}, - {"QWE:forceddemoframe", PF_forcedemoframe, QWE 103}, + bi(executecmd, QWE 83, 0), + bi(tokanize, QWE 84, 1, p(string)), /* sic */ + bi(argc, QWE 85, 0), + bi(argv, QWE 86, 1, p(float)), + bi(teamfield, QWE 87, 1, p(field)), + bi(substr, QWE 88, 3, p(string), p(float), p(float)), + bi(strcat, QWE 89, -1), + bi(strlen, QWE 90, 1, p(string)), + bi(str2byte, QWE 91, 1, p(string)), + bi(str2short, QWE 92, 1, p(string)), + bi(newstr, QWE 93, 2, p(string), p(float)), + bi(freestr, QWE 94, 1, p(string)), + bi(conprint, QWE 95, -1), + bi(readcmd, QWE 96, 1, p(string)), + bi(strcpy, QWE 97, 2, p(string), p(string)), + bi(strstr, QWE 98, 2, p(string), p(string)), + bi(strncpy, QWE 99, 3, p(string), p(string), p(float)), + bi(log, QWE 100, 3, p(string), p(float), p(string)), + bi(redirectcmd, QWE 101, 2, p(entity), p(string)), + bi(calltimeofday, QWE 102, 0), + bi(forcedemoframe, QWE 103, 1, p(float)), {0} }; #define LAST_QWE_BUILTIN 103 diff --git a/qw/source/sv_user.c b/qw/source/sv_user.c index 0d6ab4c3f..1160f673a 100644 --- a/qw/source/sv_user.c +++ b/qw/source/sv_user.c @@ -1422,7 +1422,7 @@ SV_RemoveUserCommand (void *cmd) } static void -PF_AddUserCommand (progs_t *pr) +PF_SV_AddUserCommand (progs_t *pr) { const char *name = P_GSTRING (pr, 0); ucmd_t *cmd; @@ -1999,8 +1999,11 @@ SV_ExecuteClientMessage (client_t *cl) } } +#define bi(x,np,params...) {#x, PF_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"SV_AddUserCommand", PF_AddUserCommand, -1}, + bi(SV_AddUserCommand, 3, p(string), p(func), p(int)), {0} }; diff --git a/ruamoko/cl_menu/menu.r b/ruamoko/cl_menu/menu.r index 748bd35ed..a47650a42 100644 --- a/ruamoko/cl_menu/menu.r +++ b/ruamoko/cl_menu/menu.r @@ -21,3 +21,4 @@ int () Menu_GetIndex = #0; void (void) Menu_Next = #0; void (void) Menu_Prev = #0; void (void) Menu_Enter = #0; +void (void) Menu_Leave = #0; diff --git a/ruamoko/lib/Object.r b/ruamoko/lib/Object.r index 6c7e0e6f4..bccea1de4 100644 --- a/ruamoko/lib/Object.r +++ b/ruamoko/lib/Object.r @@ -12,7 +12,7 @@ void __obj_exec_class (struct obj_module *msg) = #0; BOOL __obj_responds_to(id obj, SEL sel) = #0; void (id object, int code, string fmt, ...) obj_error = #0; void (id object, int code, string fmt, @va_list args) obj_verror = #0; -//obj_error_handler (objc_error_handler func) obj_set_error_handler = #0; +//obj_error_handler obj_set_error_handler (objc_error_handler func) = #0; IMP (id receiver, SEL op) obj_msg_lookup = #0; IMP (Super class, SEL op) obj_msg_lookup_super = #0; id (id receiver, SEL op, ...) obj_msgSend = #0; @@ -27,11 +27,11 @@ void *obj_valloc (int size) = #0; void *obj_realloc (void *mem, int size) = #0; void *obj_calloc (int nelem, int size) = #0; void obj_free (void *mem) = #0; -//(void *) (void) obj_get_uninstalled_dtable = #0; +void *obj_get_uninstalled_dtable (void) = #0; -Class (string name) obj_get_class = #0; -Class (string name) obj_lookup_class = #0; -//Class (void **enum_stage) obj_next_class = #0; +Class obj_get_class (string name) = #0; +Class obj_lookup_class (string name) = #0; +Class obj_next_class (void **enum_stage) = #0; string (SEL selector) sel_get_name = #0; string (SEL selector) sel_get_type = #0; diff --git a/ruamoko/lib/Set.r b/ruamoko/lib/Set.r index 7afc13361..4786b71a7 100644 --- a/ruamoko/lib/Set.r +++ b/ruamoko/lib/Set.r @@ -1,6 +1,7 @@ #include void set_del_iter (set_iter_t *set_iter) = #0; +unsigned set_iter_element (set_iter_t *set_iter) = #0; set_t *set_new (void) = #0; void set_delete (set_t *set) = #0; set_t *set_add (set_t *set, unsigned x) = #0; diff --git a/ruamoko/lib/key.r b/ruamoko/lib/key.r index 4b8c1a09a..812800128 100644 --- a/ruamoko/lib/key.r +++ b/ruamoko/lib/key.r @@ -5,3 +5,4 @@ string (string imt, int keynum, string binding) Key_SetBinding = #0; int (string imt, int bindnum, string binding) Key_LookupBinding = #0; int (string imt, string binding) Key_CountBinding = #0; string (int keynum) Key_KeynumToString = #0; +int (string keyname) Key_StringToKeynum = #0; diff --git a/ruamoko/qwaq/builtins/curses.c b/ruamoko/qwaq/builtins/curses.c index 1e7c7d58c..a3f83fceb 100644 --- a/ruamoko/qwaq/builtins/curses.c +++ b/ruamoko/qwaq/builtins/curses.c @@ -779,7 +779,7 @@ bi_syncprintf (progs_t *pr) } static void -bi_newwin (progs_t *pr) +bi_create_window (progs_t *pr) { qwaq_resources_t *res = PR_Resources_Find (pr, "curses"); int xpos = P_INT (pr, 0); @@ -800,7 +800,7 @@ bi_newwin (progs_t *pr) } static void -bi_delwin (progs_t *pr) +bi_destroy_window (progs_t *pr) { qwaq_resources_t *res = PR_Resources_Find (pr, "curses"); int window_id = P_INT (pr, 0); @@ -839,7 +839,7 @@ bi_getwrect (progs_t *pr) } static void -bi_new_panel (progs_t *pr) +bi_create_panel (progs_t *pr) { qwaq_resources_t *res = PR_Resources_Find (pr, "curses"); int window_id = P_INT (pr, 0); @@ -870,7 +870,7 @@ panel_command (progs_t *pr, qwaq_commands cmd) } static void -bi_del_panel (progs_t *pr) +bi_destroy_panel (progs_t *pr) { panel_command (pr, qwaq_cmd_del_panel); } @@ -1604,26 +1604,26 @@ bi_initialize (progs_t *pr) } static void -bi_c_TextContext__is_initialized (progs_t *pr) +bi__c_TextContext__is_initialized (progs_t *pr) { qwaq_resources_t *res = PR_Resources_Find (pr, "curses"); R_INT (pr) = res->initialized; } static void -bi_c_TextContext__max_colors (progs_t *pr) +bi__c_TextContext__max_colors (progs_t *pr) { bi_max_colors (pr); } static void -bi_c_TextContext__max_color_pairs (progs_t *pr) +bi__c_TextContext__max_color_pairs (progs_t *pr) { bi_max_color_pairs (pr); } static void -bi_c_TextContext__init_pair_ (progs_t *pr) +bi__c_TextContext__init_pair_ (progs_t *pr) { int pair = P_INT (pr, 2); int f = P_INT (pr, 3); @@ -1633,7 +1633,7 @@ bi_c_TextContext__init_pair_ (progs_t *pr) } static void -bi_c_TextContext__acs_char_ (progs_t *pr) +bi__c_TextContext__acs_char_ (progs_t *pr) { int acs = P_INT (pr, 2); @@ -1641,7 +1641,7 @@ bi_c_TextContext__acs_char_ (progs_t *pr) } static void -bi_c_TextContext__move_ (progs_t *pr) +bi__c_TextContext__move_ (progs_t *pr) { Point *pos = &P_PACKED (pr, Point, 2); @@ -1649,7 +1649,7 @@ bi_c_TextContext__move_ (progs_t *pr) } static void -bi_c_TextContext__curs_set_ (progs_t *pr) +bi__c_TextContext__curs_set_ (progs_t *pr) { int visibility = P_INT (pr, 2); @@ -1657,13 +1657,13 @@ bi_c_TextContext__curs_set_ (progs_t *pr) } static void -bi_c_TextContext__doupdate (progs_t *pr) +bi__c_TextContext__doupdate (progs_t *pr) { bi_doupdate (pr); } static void -bi_i_TextContext__mvprintf_ (progs_t *pr) +bi__i_TextContext__mvprintf_ (progs_t *pr) { int window_id = P_STRUCT (pr, qwaq_textcontext_t, 0).window; Point *pos = &P_PACKED (pr, Point, 2); @@ -1675,7 +1675,7 @@ bi_i_TextContext__mvprintf_ (progs_t *pr) } static void -bi_i_TextContext__printf_ (progs_t *pr) +bi__i_TextContext__printf_ (progs_t *pr) { int window_id = P_STRUCT (pr, qwaq_textcontext_t, 0).window; const char *fmt = P_GSTRING (pr, 2); @@ -1686,7 +1686,7 @@ bi_i_TextContext__printf_ (progs_t *pr) } static void -bi_i_TextContext__vprintf_ (progs_t *pr) +bi__i_TextContext__vprintf_ (progs_t *pr) { int window_id = P_STRUCT (pr, qwaq_textcontext_t, 0).window; const char *fmt = P_GSTRING (pr, 2); @@ -1696,7 +1696,7 @@ bi_i_TextContext__vprintf_ (progs_t *pr) } static void -bi_i_TextContext__addch_ (progs_t *pr) +bi__i_TextContext__addch_ (progs_t *pr) { int window_id = P_STRUCT (pr, qwaq_textcontext_t, 0).window; int ch = P_INT (pr, 2); @@ -1705,7 +1705,7 @@ bi_i_TextContext__addch_ (progs_t *pr) } static void -bi_i_TextContext__addstr_ (progs_t *pr) +bi__i_TextContext__addstr_ (progs_t *pr) { int window_id = P_STRUCT (pr, qwaq_textcontext_t, 0).window; const char *str = P_GSTRING (pr, 2); @@ -1714,7 +1714,7 @@ bi_i_TextContext__addstr_ (progs_t *pr) } static void -bi_i_TextContext__mvvprintf_ (progs_t *pr) +bi__i_TextContext__mvvprintf_ (progs_t *pr) { int window_id = P_STRUCT (pr, qwaq_textcontext_t, 0).window; Point *pos = &P_PACKED (pr, Point, 2); @@ -1725,7 +1725,7 @@ bi_i_TextContext__mvvprintf_ (progs_t *pr) } static void -bi_i_TextContext__resizeTo_ (progs_t *pr) +bi__i_TextContext__resizeTo_ (progs_t *pr) { __auto_type self = &P_STRUCT (pr, qwaq_textcontext_t, 0); int window_id = self->window; @@ -1738,14 +1738,14 @@ bi_i_TextContext__resizeTo_ (progs_t *pr) } static void -bi_c_TextContext__refresh (progs_t *pr) +bi__c_TextContext__refresh (progs_t *pr) { qwaq_update_panels (pr); qwaq_doupdate (pr); } static void -bi_i_TextContext__refresh (progs_t *pr) +bi__i_TextContext__refresh (progs_t *pr) { int window_id = P_STRUCT (pr, qwaq_textcontext_t, 0).window; @@ -1757,7 +1757,7 @@ bi_i_TextContext__refresh (progs_t *pr) } static void -bi_i_TextContext__mvaddch_ (progs_t *pr) +bi__i_TextContext__mvaddch_ (progs_t *pr) { int window_id = P_STRUCT (pr, qwaq_textcontext_t, 0).window; Point *pos = &P_PACKED (pr, Point, 2); @@ -1767,7 +1767,7 @@ bi_i_TextContext__mvaddch_ (progs_t *pr) } static void -bi_i_TextContext__mvaddstr_ (progs_t *pr) +bi__i_TextContext__mvaddstr_ (progs_t *pr) { int window_id = P_STRUCT (pr, qwaq_textcontext_t, 0).window; Point *pos = &P_PACKED (pr, Point, 2); @@ -1777,7 +1777,7 @@ bi_i_TextContext__mvaddstr_ (progs_t *pr) } static void -bi_i_TextContext__bkgd_ (progs_t *pr) +bi__i_TextContext__bkgd_ (progs_t *pr) { __auto_type self = &P_STRUCT (pr, qwaq_textcontext_t, 0); int window_id = self->window; @@ -1788,7 +1788,7 @@ bi_i_TextContext__bkgd_ (progs_t *pr) } static void -bi_i_TextContext__clear (progs_t *pr) +bi__i_TextContext__clear (progs_t *pr) { __auto_type self = &P_STRUCT (pr, qwaq_textcontext_t, 0); int window_id = self->window; @@ -1798,7 +1798,7 @@ bi_i_TextContext__clear (progs_t *pr) } static void -bi_i_TextContext__scrollok_ (progs_t *pr) +bi__i_TextContext__scrollok_ (progs_t *pr) { int window_id = P_STRUCT (pr, qwaq_textcontext_t, 0).window; int flag = P_INT (pr, 2); @@ -1807,7 +1807,7 @@ bi_i_TextContext__scrollok_ (progs_t *pr) } static void -bi_i_TextContext__border_ (progs_t *pr) +bi__i_TextContext__border_ (progs_t *pr) { int window_id = P_STRUCT (pr, qwaq_textcontext_t, 0).window; __auto_type sides = P_PACKED (pr, box_sides_t, 2); @@ -1817,7 +1817,7 @@ bi_i_TextContext__border_ (progs_t *pr) } static void -bi_i_TextContext__mvhline_ (progs_t *pr) +bi__i_TextContext__mvhline_ (progs_t *pr) { __auto_type self = &P_STRUCT (pr, qwaq_textcontext_t, 0); int window_id = self->window; @@ -1829,7 +1829,7 @@ bi_i_TextContext__mvhline_ (progs_t *pr) } static void -bi_i_TextContext__mvvline_ (progs_t *pr) +bi__i_TextContext__mvvline_ (progs_t *pr) { __auto_type self = &P_STRUCT (pr, qwaq_textcontext_t, 0); int window_id = self->window; @@ -1854,74 +1854,95 @@ bi_curses_clear (progs_t *pr, void *data) panel_reset (res); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"initialize", bi_initialize, -1}, - {"syncprintf", bi_syncprintf, -1}, - {"create_window", bi_newwin, -1}, - {"destroy_window", bi_delwin, -1}, - {"getwrect", bi_getwrect, -1}, - {"create_panel", bi_new_panel, -1}, - {"destroy_panel", bi_del_panel, -1}, - {"hide_panel", bi_hide_panel, -1}, - {"show_panel", bi_show_panel, -1}, - {"top_panel", bi_top_panel, -1}, - {"bottom_panel", bi_bottom_panel, -1}, - {"move_panel", bi_move_panel, -1}, - {"panel_window", bi_panel_window, -1}, - {"replace_panel", bi_replace_panel, -1}, - {"update_panels", bi_update_panels, -1}, - {"doupdate", bi_doupdate, -1}, - {"mvwprintf", bi_mvwprintf, -1}, - {"wprintf", bi_wprintf, -1}, - {"wvprintf", bi_wvprintf, -1}, - {"mvwvprintf", bi_mvwvprintf, -1}, - {"mvwaddch", bi_mvwaddch, -1}, - {"waddch", bi_waddch, -1}, - {"mvwaddstr", bi_mvwaddstr, -1}, - {"waddstr", bi_waddstr, -1}, - {"wrefresh", bi_wrefresh, -1}, - {"max_colors", bi_max_colors, -1}, - {"max_color_pairs", bi_max_color_pairs, -1}, - {"init_pair", bi_init_pair, -1}, - {"wbkgd", bi_wbkgd, -1}, - {"werase", bi_werase, -1}, - {"scrollok", bi_scrollok, -1}, - {"wmove", bi_wmove, -1}, - {"acs_char", bi_acs_char, -1}, - {"move", bi_move, -1}, - {"curs_set", bi_curs_set, -1}, - {"wborder", bi_wborder, -1}, - {"mvwblit_line", bi_mvwblit_line, -1}, - {"wresize", bi_wresize, -1}, - {"resizeterm", bi_resizeterm, -1}, - {"mvwhline", bi_mvwhline, -1}, - {"mvwvline", bi_mvwvline, -1}, + bi(initialize, 0), + bi(syncprintf, -2, p(string)), + bi(create_window, 4, p(int), p(int), p(int), p(int)), + bi(destroy_window, 1, p(ptr)), + bi(getwrect, 1, p(ptr)), + bi(create_panel, 1, p(ptr)), + bi(destroy_panel, 1, p(ptr)), + bi(hide_panel, 1, p(ptr)), + bi(show_panel, 1, p(ptr)), + bi(top_panel, 1, p(ptr)), + bi(bottom_panel, 1, p(ptr)), + bi(move_panel, 3, p(ptr), p(int), p(int)), + bi(panel_window, 1, p(ptr)), + bi(replace_panel, 2, p(ptr), p(ptr)), + bi(update_panels, 0), + bi(doupdate, 0), + bi(mvwprintf, -5, p(ptr), p(int), p(int), p(string)), + bi(wprintf, -3, p(ptr), p(string)), + bi(wvprintf, 3, p(ptr), p(string), P(1, 2)), + bi(mvwvprintf, 5, p(ptr), p(int), p(int), p(string), P(1, 2)), + bi(mvwaddch, 4, p(ptr), p(int), p(int), p(int)), + bi(waddch, 2, p(ptr), p(int)), + bi(mvwaddstr, 4, p(ptr), p(int), p(int), p(string)), + bi(waddstr, 2, p(ptr), p(string)), + bi(wrefresh, 1, p(ptr)), + bi(max_colors, 0), + bi(max_color_pairs, 0), + bi(init_pair, 3, p(int), p(int), p(int)), + bi(wbkgd, 2, p(ptr), p(int)), + bi(werase, 1, p(ptr)), + bi(scrollok, 2, p(ptr), p(int)), + bi(wmove, 3, p(ptr), p(int), p(int), p(int)), + bi(acs_char, 1, p(int)), + bi(move, 2, p(int), p(int)), + bi(curs_set, 1, p(int)), + bi(wborder, 3, p(ptr), P(1, 4), P(1, 4)), + bi(mvwblit_line, 5, p(ptr), p(int), p(int), p(ptr), p(int)), + bi(wresize, 3, p(ptr), p(int), p(int)), + bi(resizeterm, 2, p(int), p(int)), + bi(mvwhline, 5, p(ptr), p(int), p(int), p(int), p(int)), + bi(mvwvline, 5, p(ptr), p(int), p(int), p(int), p(int)), - {"_c_TextContext__is_initialized", bi_c_TextContext__is_initialized, -1}, - {"_c_TextContext__max_colors", bi_c_TextContext__max_colors, -1}, - {"_c_TextContext__max_color_pairs", bi_c_TextContext__max_color_pairs, -1}, - {"_c_TextContext__init_pair_", bi_c_TextContext__init_pair_, -1}, - {"_c_TextContext__acs_char_", bi_c_TextContext__acs_char_, -1}, - {"_c_TextContext__move_", bi_c_TextContext__move_, -1}, - {"_c_TextContext__curs_set_", bi_c_TextContext__curs_set_, -1}, - {"_c_TextContext__doupdate", bi_c_TextContext__doupdate, -1}, - {"_i_TextContext__mvprintf_", bi_i_TextContext__mvprintf_, -1}, - {"_i_TextContext__printf_", bi_i_TextContext__printf_, -1}, - {"_i_TextContext__vprintf_", bi_i_TextContext__vprintf_, -1}, - {"_i_TextContext__addch_", bi_i_TextContext__addch_, -1}, - {"_i_TextContext__addstr_", bi_i_TextContext__addstr_, -1}, - {"_i_TextContext__mvvprintf_", bi_i_TextContext__mvvprintf_, -1}, - {"_i_TextContext__resizeTo_", bi_i_TextContext__resizeTo_, -1}, - {"_c_TextContext__refresh", bi_c_TextContext__refresh, -1}, - {"_i_TextContext__refresh", bi_i_TextContext__refresh, -1}, - {"_i_TextContext__mvaddch_", bi_i_TextContext__mvaddch_, -1}, - {"_i_TextContext__mvaddstr_", bi_i_TextContext__mvaddstr_, -1}, - {"_i_TextContext__bkgd_", bi_i_TextContext__bkgd_, -1}, - {"_i_TextContext__clear", bi_i_TextContext__clear, -1}, - {"_i_TextContext__scrollok_", bi_i_TextContext__scrollok_, -1}, - {"_i_TextContext__border_", bi_i_TextContext__border_, -1}, - {"_i_TextContext__mvhline_", bi_i_TextContext__mvhline_, -1}, - {"_i_TextContext__mvvline_", bi_i_TextContext__mvvline_, -1}, + bi(_c_TextContext__is_initialized, 2, p(ptr), p(ptr)), + bi(_c_TextContext__max_colors, 2, p(ptr), p(ptr)), + bi(_c_TextContext__max_color_pairs, 2, p(ptr), p(ptr)), + bi(_c_TextContext__init_pair_, 5, p(ptr), p(ptr), + p(int), p(int), p(int)), + bi(_c_TextContext__acs_char_, 3, p(ptr), p(ptr), + p(int)), + bi(_c_TextContext__move_, 3, p(ptr), p(ptr), + P(1, 2)), + bi(_c_TextContext__curs_set_, 3, p(ptr), p(ptr), + p(int)), + bi(_c_TextContext__doupdate, 2, p(ptr), p(ptr)), + bi(_i_TextContext__mvprintf_, -5, p(ptr), p(ptr), + P(1, 2), p(string)), + bi(_i_TextContext__printf_, -4, p(ptr), p(ptr), + p(string)), + bi(_i_TextContext__vprintf_, 4, p(ptr), p(ptr), + p(string), P(1, 2)), + bi(_i_TextContext__addch_, 3, p(ptr), p(ptr), + p(int)), + bi(_i_TextContext__addstr_, 3, p(ptr), p(ptr), + p(string)), + bi(_i_TextContext__mvvprintf_, 5, p(ptr), p(ptr), + P(1, 2), p(string), P(1, 2)), + bi(_i_TextContext__resizeTo_, 3, p(ptr), p(ptr), + P(1, 2)), + bi(_c_TextContext__refresh, 2, p(ptr), p(ptr)), + bi(_i_TextContext__refresh, 2, p(ptr), p(ptr)), + bi(_i_TextContext__mvaddch_, 4, p(ptr), p(ptr), + P(1, 2), p(int)), + bi(_i_TextContext__mvaddstr_, 4, p(ptr), p(ptr), + P(1, 2), p(string)), + bi(_i_TextContext__bkgd_, 3, p(ptr), p(ptr), + p(int)), + bi(_i_TextContext__clear, 2, p(ptr), p(ptr)), + bi(_i_TextContext__scrollok_, 3, p(ptr), p(ptr), + p(int)), + bi(_i_TextContext__border_, 4, p(ptr), p(ptr), + P(1, 4), P(1, 4)), + bi(_i_TextContext__mvhline_, 5, p(ptr), p(ptr), + P(1, 2), p(int), p(int)), + bi(_i_TextContext__mvvline_, 5, p(ptr), p(ptr), + P(1, 2), p(int), p(int)), {0} }; diff --git a/ruamoko/qwaq/builtins/debug.c b/ruamoko/qwaq/builtins/debug.c index 2738a8589..98c7294c7 100644 --- a/ruamoko/qwaq/builtins/debug.c +++ b/ruamoko/qwaq/builtins/debug.c @@ -649,30 +649,32 @@ qdb_get_source_line_addr (progs_t *pr) R_UINT (pr) = PR_FindSourceLineAddr (tpr, file, line); } +#define bi(x,np,params...) {#x, x, -1, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"qdb_set_trace", qdb_set_trace, -1}, - {"qdb_set_breakpoint", qdb_set_breakpoint, -1}, - {"qdb_clear_breakpoint", qdb_clear_breakpoint, -1}, - {"qdb_set_watchpoint", qdb_set_watchpoint, -1}, - {"qdb_clear_watchpoint", qdb_clear_watchpoint, -1}, - {"qdb_continue", qdb_continue, -1}, - {"qdb_get_state", qdb_get_state, -1}, - {"qdb_get_stack_depth", qdb_get_stack_depth, -1}, - {"qdb_get_stack", qdb_get_stack, -1}, - {"qdb_get_event", qdb_get_event, -1}, - {"qdb_get_data", qdb_get_data, -1}, - {"qdb_get_string|{tag qdb_target_s=}I", qdb_get_string, -1}, - {"qdb_get_string|{tag qdb_target_s=}*", qdb_get_string, -1}, - {"qdb_get_file_path", qdb_get_file_path, -1}, - {"qdb_find_string", qdb_find_string, -1}, - {"qdb_find_global", qdb_find_global, -1}, - {"qdb_find_field", qdb_find_field, -1}, - {"qdb_find_function", qdb_find_function, -1}, - {"qdb_get_function", qdb_get_function, -1}, - {"qdb_find_auxfunction", qdb_find_auxfunction, -1}, - {"qdb_get_auxfunction", qdb_get_auxfunction, -1}, - {"qdb_get_local_defs", qdb_get_local_defs, -1}, - {"qdb_get_source_line_addr", qdb_get_source_line_addr, -1}, + bi(qdb_set_trace, 2, p(int), p(int)), + bi(qdb_set_breakpoint, 2, p(int), p(uint)), + bi(qdb_clear_breakpoint, 2, p(int), p(uint)), + bi(qdb_set_watchpoint, 2, p(int), p(uint)), + bi(qdb_clear_watchpoint, 1, p(int)), + bi(qdb_continue, 1, p(int)), + bi(qdb_get_state, 1, p(int)), + bi(qdb_get_stack_depth, 1, p(int)), + bi(qdb_get_stack, 1, p(int)), + bi(qdb_get_event, 2, p(int), p(ptr)), + bi(qdb_get_data, 4, p(int), p(uint), p(uint), p(ptr)), + {"qdb_get_string|{tag qdb_target_s=}I", qdb_get_string, -1, 1, {p(uint)}}, + {"qdb_get_string|{tag qdb_target_s=}*", qdb_get_string, -1, 1, {p(string)}}, + bi(qdb_get_file_path, 2, p(int), p(string)), + bi(qdb_find_string, 2, p(int), p(string)), + bi(qdb_find_global, 2, p(int), p(string)), + bi(qdb_find_field, 2, p(int), p(string)), + bi(qdb_find_function, 2, p(int), p(string)), + bi(qdb_get_function, 2, p(int), p(uint)), + bi(qdb_find_auxfunction, 2, p(int), p(string)), + bi(qdb_get_auxfunction, 2, p(int), p(uint)), + bi(qdb_get_local_defs, 2, p(int), p(uint)), + bi(qdb_get_source_line_addr, 3, p(int), p(string), p(uint)), {} }; diff --git a/ruamoko/qwaq/builtins/editbuffer.c b/ruamoko/qwaq/builtins/editbuffer.c index cea68c941..db3237a2e 100644 --- a/ruamoko/qwaq/builtins/editbuffer.c +++ b/ruamoko/qwaq/builtins/editbuffer.c @@ -575,7 +575,7 @@ formatLine (txtbuffer_t *buffer, unsigned linePtr, unsigned xpos, //=== static void -bi_i_EditBuffer__init (progs_t *pr) +bi__i_EditBuffer__init (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); __auto_type self = &P_STRUCT (pr, qwaq_editbuffer_t, 0); @@ -591,7 +591,7 @@ bi_i_EditBuffer__init (progs_t *pr) } static void -bi_i_EditBuffer__initWithFile_ (progs_t *pr) +bi__i_EditBuffer__initWithFile_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); __auto_type self = &P_STRUCT (pr, qwaq_editbuffer_t, 0); @@ -610,7 +610,7 @@ bi_i_EditBuffer__initWithFile_ (progs_t *pr) } static void -bi_i_EditBuffer__dealloc (progs_t *pr) +bi__i_EditBuffer__dealloc (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); __auto_type self = &P_STRUCT (pr, qwaq_editbuffer_t, 0); @@ -622,7 +622,7 @@ bi_i_EditBuffer__dealloc (progs_t *pr) } static void -bi_i_EditBuffer__nextChar_ (progs_t *pr) +bi__i_EditBuffer__nextChar_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -633,7 +633,7 @@ bi_i_EditBuffer__nextChar_ (progs_t *pr) } static void -bi_i_EditBuffer__prevChar_ (progs_t *pr) +bi__i_EditBuffer__prevChar_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -644,7 +644,7 @@ bi_i_EditBuffer__prevChar_ (progs_t *pr) } static void -bi_i_EditBuffer__nextNonSpace_ (progs_t *pr) +bi__i_EditBuffer__nextNonSpace_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -655,7 +655,7 @@ bi_i_EditBuffer__nextNonSpace_ (progs_t *pr) } static void -bi_i_EditBuffer__prevNonSpace_ (progs_t *pr) +bi__i_EditBuffer__prevNonSpace_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -666,7 +666,7 @@ bi_i_EditBuffer__prevNonSpace_ (progs_t *pr) } static void -bi_i_EditBuffer__isWord_ (progs_t *pr) +bi__i_EditBuffer__isWord_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -677,7 +677,7 @@ bi_i_EditBuffer__isWord_ (progs_t *pr) } static void -bi_i_EditBuffer__nextWord_ (progs_t *pr) +bi__i_EditBuffer__nextWord_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -688,7 +688,7 @@ bi_i_EditBuffer__nextWord_ (progs_t *pr) } static void -bi_i_EditBuffer__prevWord_ (progs_t *pr) +bi__i_EditBuffer__prevWord_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -699,7 +699,7 @@ bi_i_EditBuffer__prevWord_ (progs_t *pr) } static void -bi_i_EditBuffer__nextLine_ (progs_t *pr) +bi__i_EditBuffer__nextLine_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -710,7 +710,7 @@ bi_i_EditBuffer__nextLine_ (progs_t *pr) } static void -bi_i_EditBuffer__prevLine_ (progs_t *pr) +bi__i_EditBuffer__prevLine_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -721,7 +721,7 @@ bi_i_EditBuffer__prevLine_ (progs_t *pr) } static void -bi_i_EditBuffer__nextLine__ (progs_t *pr) +bi__i_EditBuffer__nextLine__ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -742,7 +742,7 @@ bi_i_EditBuffer__nextLine__ (progs_t *pr) } static void -bi_i_EditBuffer__prevLine__ (progs_t *pr) +bi__i_EditBuffer__prevLine__ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -757,7 +757,7 @@ bi_i_EditBuffer__prevLine__ (progs_t *pr) } static void -bi_i_EditBuffer__charPos_at_ (progs_t *pr) +bi__i_EditBuffer__charPos_at_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -770,7 +770,7 @@ bi_i_EditBuffer__charPos_at_ (progs_t *pr) } static void -bi_i_EditBuffer__charPtr_at_ (progs_t *pr) +bi__i_EditBuffer__charPtr_at_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -783,7 +783,7 @@ bi_i_EditBuffer__charPtr_at_ (progs_t *pr) } static void -bi_i_EditBuffer__getWord_ (progs_t *pr) +bi__i_EditBuffer__getWord_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -797,7 +797,7 @@ bi_i_EditBuffer__getWord_ (progs_t *pr) } static void -bi_i_EditBuffer__getLine_ (progs_t *pr) +bi__i_EditBuffer__getLine_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -811,7 +811,7 @@ bi_i_EditBuffer__getLine_ (progs_t *pr) } static void -bi_i_EditBuffer__getBOL_ (progs_t *pr) +bi__i_EditBuffer__getBOL_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -822,7 +822,7 @@ bi_i_EditBuffer__getBOL_ (progs_t *pr) } static void -bi_i_EditBuffer__getEOL_ (progs_t *pr) +bi__i_EditBuffer__getEOL_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -833,7 +833,7 @@ bi_i_EditBuffer__getEOL_ (progs_t *pr) } static void -bi_i_EditBuffer__getBOT (progs_t *pr) +bi__i_EditBuffer__getBOT (progs_t *pr) { //qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); //int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -843,7 +843,7 @@ bi_i_EditBuffer__getBOT (progs_t *pr) } static void -bi_i_EditBuffer__getEOT (progs_t *pr) +bi__i_EditBuffer__getEOT (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -853,7 +853,7 @@ bi_i_EditBuffer__getEOT (progs_t *pr) } static void -bi_i_EditBuffer__readString_ (progs_t *pr) +bi__i_EditBuffer__readString_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -868,7 +868,7 @@ bi_i_EditBuffer__readString_ (progs_t *pr) } static void -bi_i_EditBuffer__getChar_ (progs_t *pr) +bi__i_EditBuffer__getChar_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -882,7 +882,7 @@ bi_i_EditBuffer__getChar_ (progs_t *pr) } static void -bi_i_EditBuffer__putChar_at_ (progs_t *pr) +bi__i_EditBuffer__putChar_at_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -897,7 +897,7 @@ bi_i_EditBuffer__putChar_at_ (progs_t *pr) } static void -bi_i_EditBuffer__insertChar_at_ (progs_t *pr) +bi__i_EditBuffer__insertChar_at_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -912,7 +912,7 @@ bi_i_EditBuffer__insertChar_at_ (progs_t *pr) } static void -bi_i_EditBuffer__countLines_ (progs_t *pr) +bi__i_EditBuffer__countLines_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -924,7 +924,7 @@ bi_i_EditBuffer__countLines_ (progs_t *pr) } static void -bi_i_EditBuffer__search_for_direction_ (progs_t *pr) +bi__i_EditBuffer__search_for_direction_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -938,7 +938,7 @@ bi_i_EditBuffer__search_for_direction_ (progs_t *pr) } static void -bi_i_EditBuffer__isearch_for_direction_ (progs_t *pr) +bi__i_EditBuffer__isearch_for_direction_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -952,7 +952,7 @@ bi_i_EditBuffer__isearch_for_direction_ (progs_t *pr) } static void -bi_i_EditBuffer__formatLine_from_into_width_highlight_colors_ (progs_t *pr) +bi__i_EditBuffer__formatLine_from_into_width_highlight_colors_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -972,7 +972,7 @@ bi_i_EditBuffer__formatLine_from_into_width_highlight_colors_ (progs_t *pr) } static void -bi_i_EditBuffer__modified (progs_t *pr) +bi__i_EditBuffer__modified (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -981,7 +981,7 @@ bi_i_EditBuffer__modified (progs_t *pr) } static void -bi_i_EditBuffer__textSize (progs_t *pr) +bi__i_EditBuffer__textSize (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -990,7 +990,7 @@ bi_i_EditBuffer__textSize (progs_t *pr) } static void -bi_i_EditBuffer__saveFile_ (progs_t *pr) +bi__i_EditBuffer__saveFile_ (progs_t *pr) { qwaq_ebresources_t *res = PR_Resources_Find (pr, "qwaq-editbuffer"); int buffer_id = P_STRUCT (pr, qwaq_editbuffer_t, 0).buffer; @@ -1015,43 +1015,47 @@ qwaq_ebresources_clear (progs_t *pr, void *data) editbuffer_reset (res); } +#define bi(x,n,np,params...) {#x, bi_##x, n, np, {params}} +#define p(type) PR_PARAM(type) +#define P(a, s) { .size = (s), .alignment = BITOP_LOG2 (a), } static builtin_t builtins[] = { - {"_i_EditBuffer__init", bi_i_EditBuffer__init, -1}, - {"_i_EditBuffer__initWithFile_", bi_i_EditBuffer__initWithFile_, -1}, - {"_i_EditBuffer__dealloc", bi_i_EditBuffer__dealloc, -1}, - {"_i_EditBuffer__nextChar_", bi_i_EditBuffer__nextChar_, -1}, - {"_i_EditBuffer__prevChar_", bi_i_EditBuffer__prevChar_, -1}, - {"_i_EditBuffer__nextNonSpace_", bi_i_EditBuffer__nextNonSpace_, -1}, - {"_i_EditBuffer__prevNonSpace_", bi_i_EditBuffer__prevNonSpace_, -1}, - {"_i_EditBuffer__isWord_", bi_i_EditBuffer__isWord_, -1}, - {"_i_EditBuffer__nextWord_", bi_i_EditBuffer__nextWord_, -1}, - {"_i_EditBuffer__prevWord_", bi_i_EditBuffer__prevWord_, -1}, - {"_i_EditBuffer__nextLine_", bi_i_EditBuffer__nextLine_, -1}, - {"_i_EditBuffer__prevLine_", bi_i_EditBuffer__prevLine_, -1}, - {"_i_EditBuffer__nextLine__", bi_i_EditBuffer__nextLine__, -1}, - {"_i_EditBuffer__prevLine__", bi_i_EditBuffer__prevLine__, -1}, - {"_i_EditBuffer__charPos_at_", bi_i_EditBuffer__charPos_at_, -1}, - {"_i_EditBuffer__charPtr_at_", bi_i_EditBuffer__charPtr_at_, -1}, - {"_i_EditBuffer__getWord_", bi_i_EditBuffer__getWord_, -1}, - {"_i_EditBuffer__getLine_", bi_i_EditBuffer__getLine_, -1}, - {"_i_EditBuffer__getBOL_", bi_i_EditBuffer__getBOL_, -1}, - {"_i_EditBuffer__getEOL_", bi_i_EditBuffer__getEOL_, -1}, - {"_i_EditBuffer__getBOT", bi_i_EditBuffer__getBOT, -1}, - {"_i_EditBuffer__getEOT", bi_i_EditBuffer__getEOT, -1}, - {"_i_EditBuffer__readString_", bi_i_EditBuffer__readString_, -1}, - {"_i_EditBuffer__getChar_", bi_i_EditBuffer__getChar_, -1}, - {"_i_EditBuffer__putChar_at_", bi_i_EditBuffer__putChar_at_, -1}, - {"_i_EditBuffer__insertChar_at_", bi_i_EditBuffer__insertChar_at_,-1}, - {"_i_EditBuffer__countLines_", bi_i_EditBuffer__countLines_, -1}, - {"_i_EditBuffer__search_for_direction_", - bi_i_EditBuffer__search_for_direction_, -1}, - {"_i_EditBuffer__isearch_for_direction_", - bi_i_EditBuffer__isearch_for_direction_,-1}, - {"_i_EditBuffer__formatLine_from_into_width_highlight_colors_", - bi_i_EditBuffer__formatLine_from_into_width_highlight_colors_, -1}, - {"_i_EditBuffer__modified", bi_i_EditBuffer__modified, -1}, - {"_i_EditBuffer__textSize", bi_i_EditBuffer__textSize, -1}, - {"_i_EditBuffer__saveFile_", bi_i_EditBuffer__saveFile_, -1}, + bi(_i_EditBuffer__init, -1, 2, p(ptr), p(ptr)), + bi(_i_EditBuffer__initWithFile_, -1, 3, p(ptr), p(ptr), p(string)), + bi(_i_EditBuffer__dealloc, -1, 2, p(ptr), p(ptr)), + bi(_i_EditBuffer__nextChar_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__prevChar_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__nextNonSpace_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__prevNonSpace_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__isWord_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__nextWord_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__prevWord_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__nextLine_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__prevLine_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__nextLine__, -1, 4, p(ptr), p(ptr), p(uint), p(uint)), + bi(_i_EditBuffer__prevLine__, -1, 4, p(ptr), p(ptr), p(uint), p(uint)), + bi(_i_EditBuffer__charPos_at_, -1, 4, p(ptr), p(ptr), p(uint), p(uint)), + bi(_i_EditBuffer__charPtr_at_, -1, 4, p(ptr), p(ptr), p(uint), p(uint)), + bi(_i_EditBuffer__getWord_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__getLine_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__getBOL_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__getEOL_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__getBOT, -1, 2, p(ptr), p(ptr)), + bi(_i_EditBuffer__getEOT, -1, 2, p(ptr), p(ptr)), + bi(_i_EditBuffer__readString_, -1, 3, p(ptr), p(ptr), P(1, 2)), + bi(_i_EditBuffer__getChar_, -1, 3, p(ptr), p(ptr), p(uint)), + bi(_i_EditBuffer__putChar_at_, -1, 4, p(ptr), p(ptr), p(int), p(uint)), + bi(_i_EditBuffer__insertChar_at_, -1, 4, p(ptr), p(ptr), p(int), p(uint)), + bi(_i_EditBuffer__countLines_, -1, 3, p(ptr), p(ptr), P(1, 2)), + bi(_i_EditBuffer__search_for_direction_, -1, + 5, p(ptr), p(ptr), P(1, 2), p(string), p(int)), + bi(_i_EditBuffer__isearch_for_direction_,-1, + 5, p(ptr), p(ptr), P(1, 2), p(string), p(int)), + bi(_i_EditBuffer__formatLine_from_into_width_highlight_colors_, -1, + 8, p(ptr), p(ptr), + p(uint), p(uint), p(ptr), p(uint), P(1, 2), P(1, 2)), + bi(_i_EditBuffer__modified, -1, 2, p(ptr), p(ptr)), + bi(_i_EditBuffer__textSize, -1, 2, p(ptr), p(ptr)), + bi(_i_EditBuffer__saveFile_, -1, 3, p(ptr), p(ptr), p(string)), {} }; diff --git a/ruamoko/qwaq/builtins/graphics.c b/ruamoko/qwaq/builtins/graphics.c index 847a13357..cd523b20a 100644 --- a/ruamoko/qwaq/builtins/graphics.c +++ b/ruamoko/qwaq/builtins/graphics.c @@ -120,15 +120,17 @@ bi_refresh_2d (progs_t *pr) } static void -bi_shutdown_ (progs_t *pr) +bi_shutdown (progs_t *pr) { Sys_Shutdown (); } +#define bi(x,n,np,params...) {#x, bi_##x, n, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"refresh", bi_refresh, -1}, - {"refresh_2d", bi_refresh_2d, -1}, - {"shutdown", bi_shutdown_, -1}, + bi(refresh, -1, 0), + bi(refresh_2d, -1, 1, p(func)), + bi(shutdown, -1, 0), {0} }; @@ -139,7 +141,7 @@ event_handler (const IE_event_t *ie_event, void *_pr) } static void -bi_shutdown (void *data) +BI_shutdown (void *data) { } @@ -155,7 +157,7 @@ BI_Graphics_Init (progs_t *pr) PI_Init (); PI_RegisterPlugins (client_plugin_list); - Sys_RegisterShutdown (bi_shutdown, pr); + Sys_RegisterShutdown (BI_shutdown, pr); VID_Init_Cvars (); IN_Init_Cvars (); diff --git a/ruamoko/qwaq/builtins/main.c b/ruamoko/qwaq/builtins/main.c index 185998fde..955195b65 100644 --- a/ruamoko/qwaq/builtins/main.c +++ b/ruamoko/qwaq/builtins/main.c @@ -172,10 +172,12 @@ bi_traceoff (progs_t *pr) pr->pr_trace = false; } +#define bi(x,n,np,params...) {#x, bi_##x, n, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t common_builtins[] = { - {"printf", bi_printf, -1}, - {"traceon", bi_traceon, -1}, - {"traceoff", bi_traceoff, -1}, + bi(printf, -1, -2, p(string)), + bi(traceon, -1, 0), + bi(traceoff, -1, 0), {}, }; diff --git a/ruamoko/qwaq/builtins/term-input.c b/ruamoko/qwaq/builtins/term-input.c index 697cd2e7c..e8d136855 100644 --- a/ruamoko/qwaq/builtins/term-input.c +++ b/ruamoko/qwaq/builtins/term-input.c @@ -868,11 +868,13 @@ bi_init_input (progs_t *pr) IE_Send_Event (&event); } +#define bi(x,n,np,params...) {#x, bi_##x, n, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"send_connected_devices", bi_send_connected_devices, -1}, - {"get_device_info", bi_get_device_info, -1}, - {"get_event", bi_get_event, -1}, - {"init_input", bi_init_input, -1}, + bi(send_connected_devices, -1, 0), + bi(get_device_info, -1, 1, p(int)), + bi(get_event, -1, 1, p(ptr)), + bi(init_input, -1, 0), {0} }; diff --git a/tools/qfcc/test/test-bi.c b/tools/qfcc/test/test-bi.c index bec2b247e..58b1e28d2 100644 --- a/tools/qfcc/test/test-bi.c +++ b/tools/qfcc/test/test-bi.c @@ -95,13 +95,15 @@ bi_remove (progs_t *pr) ED_Free (pr, ed); } +#define bi(x,np,params...) {#x, bi_##x, -1, np, {params}} +#define p(type) PR_PARAM(type) static builtin_t builtins[] = { - {"printf", bi_printf, -1}, - {"errno", bi_errno, -1}, - {"strerror", bi_strerror, -1}, - {"exit", bi_exit, -1}, - {"spawn", bi_spawn, -1}, - {"remove", bi_remove, -1}, + bi(printf, -2, p(string)), + bi(errno, 0), + bi(strerror, 1, p(int)), + bi(exit, 1, p(int)), + bi(spawn, 0), + bi(remove, 1, p(entity)), {0} }; From a818fa4b8e9637d5124c918fdef2e02c2a80ab2b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 24 Jan 2022 00:13:44 +0900 Subject: [PATCH 208/360] [gamecode] Rearrange bfunction_t in preparation for param offsets The builtin and progs function data is overlaid so the extra data doesn't cause too much memory to be used (it's actually 8 bytes smaller now). The plan is to pre-compute the offsets based on the parameter size and alignment data. --- include/QF/progs.h | 24 ++++++++++++++++++------ libs/gamecode/pr_exec.c | 6 ++++-- 2 files changed, 22 insertions(+), 8 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 25f0d1a4e..bac575b87 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1221,13 +1221,25 @@ typedef struct { */ typedef struct { pr_int_t first_statement; - pr_int_t parm_start; - pr_int_t locals; - pr_uint_t profile; pr_int_t numparms; - dparmsize_t parm_size[PR_MAX_PARAMS]; - dfunction_t *descriptor; - builtin_proc func; + union { + struct { + dparmsize_t parm_size[PR_MAX_PARAMS]; + dfunction_t *descriptor; + pr_uint_t parm_start; + pr_uint_t locals; + pr_uint_t profile; + }; + struct { + // although Ruamoko progs support more than PR_MAX_PARAMS + // arguments, only the first PR_MAX_PARAMS parameter pointers + // are initialized. This keeps builtins meant for both ISAs + // simple as they either will never accept more tha PR_MAX_PARAMS + // arugments, or they'll be modified to do the right thing. + pr_ushort_t param_offsets[PR_MAX_PARAMS]; + builtin_proc func; + }; + }; } bfunction_t; /** Register a set of builtin functions with the VM. Different VMs within the diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 0d8424857..19507665c 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -284,9 +284,11 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) sizeof (pr_type_t) * f->locals); pr->localstack_used += f->locals; - if (pr_deadbeef_locals->int_val) - for (i = f->parm_start; i < f->parm_start + f->locals; i++) + if (pr_deadbeef_locals->int_val) { + for (pr_uint_t i = f->parm_start; i < f->parm_start + f->locals; i++) { pr->pr_globals[i].int_var = 0xdeadbeef; + } + } // copy parameters if (f->numparms >= 0) { From 9c51c3d2e1d0719906dc7d8ef26ac11b9a29815b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 24 Jan 2022 00:20:05 +0900 Subject: [PATCH 209/360] [gamecode] Add a data pointer passed to builtin functions This is part of the work for #26 (Record resource pointer with builtin function data). Currently, the data pointer gets as far as the per-instance VM function table (I don't feel like tackling the job of converting all the builtin functions tonight). All the builtin modules that register a resources data block pass that block on to PR_RegisterBuiltins. --- include/QF/progs.h | 8 +++++++- libs/audio/snd_progs.c | 2 +- libs/console/bi_inputline.c | 2 +- libs/console/menu.c | 2 +- libs/gamecode/pr_builtins.c | 15 +++++++++++---- libs/gib/bi_gib.c | 5 ++--- libs/ruamoko/pr_cmds.c | 2 +- libs/ruamoko/rua_cbuf.c | 2 +- libs/ruamoko/rua_cmd.c | 4 ++-- libs/ruamoko/rua_cvar.c | 3 +-- libs/ruamoko/rua_hash.c | 2 +- libs/ruamoko/rua_input.c | 8 ++++---- libs/ruamoko/rua_keys.c | 2 +- libs/ruamoko/rua_math.c | 2 +- libs/ruamoko/rua_mersenne.c | 2 +- libs/ruamoko/rua_msgbuf.c | 2 +- libs/ruamoko/rua_obj.c | 3 +-- libs/ruamoko/rua_plist.c | 2 +- libs/ruamoko/rua_qfile.c | 6 +++--- libs/ruamoko/rua_qfs.c | 2 +- libs/ruamoko/rua_runtime.c | 2 +- libs/ruamoko/rua_script.c | 3 +-- libs/ruamoko/rua_set.c | 2 +- libs/ruamoko/rua_stdlib.c | 2 +- libs/ruamoko/rua_string.c | 2 +- libs/video/renderer/r_progs.c | 2 +- nq/source/sv_pr_cmds.c | 2 +- qw/source/sv_pr_cmds.c | 2 +- qw/source/sv_pr_cpqw.c | 2 +- qw/source/sv_pr_qwe.c | 2 +- qw/source/sv_user.c | 2 +- ruamoko/qwaq/builtins/curses.c | 2 +- ruamoko/qwaq/builtins/debug.c | 2 +- ruamoko/qwaq/builtins/editbuffer.c | 2 +- ruamoko/qwaq/builtins/graphics.c | 2 +- ruamoko/qwaq/builtins/main.c | 2 +- ruamoko/qwaq/builtins/term-input.c | 2 +- tools/qfcc/test/test-bi.c | 2 +- 38 files changed, 61 insertions(+), 52 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index bac575b87..066a479af 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1208,6 +1208,9 @@ typedef struct { /// The encoding is the same as for progs functions, with 3:5 for /// alignment:size (size 0 means 32 words). dparmsize_t params[PR_MAX_PARAMS]; + + /// Data passed to builtin functions. Set by PR_RegisterBuiltins + void *data; } builtin_t; #define PR_PARAM(type) { \ @@ -1238,6 +1241,7 @@ typedef struct { // arugments, or they'll be modified to do the right thing. pr_ushort_t param_offsets[PR_MAX_PARAMS]; builtin_proc func; + void *data; ///< extra data passed to the builtin }; }; } bfunction_t; @@ -1247,8 +1251,10 @@ typedef struct { for the same VM, but redefining a builtin is an error. \param pr pointer to ::progs_t VM struct \param builtins array of builtin_t builtins + \param data pointer to builtin-specific data. Usually the resources + struct registered with PR_Resources_Register */ -void PR_RegisterBuiltins (progs_t *pr, builtin_t *builtins); +void PR_RegisterBuiltins (progs_t *pr, builtin_t *builtins, void *data); /** Lookup a builtin function referred by name. \param pr pointer to ::progs_t VM struct diff --git a/libs/audio/snd_progs.c b/libs/audio/snd_progs.c index 8e77bdde7..912686412 100644 --- a/libs/audio/snd_progs.c +++ b/libs/audio/snd_progs.c @@ -57,5 +57,5 @@ static builtin_t builtins[] = { VISIBLE void S_Progs_Init (progs_t *pr) { - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, 0); } diff --git a/libs/console/bi_inputline.c b/libs/console/bi_inputline.c index af8fba096..69494450f 100644 --- a/libs/console/bi_inputline.c +++ b/libs/console/bi_inputline.c @@ -328,7 +328,7 @@ InputLine_Progs_Init (progs_t *pr) il_resources_t *res = calloc (1, sizeof (il_resources_t)); PR_Resources_Register (pr, "InputLine", res, bi_il_clear); - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); } VISIBLE void diff --git a/libs/console/menu.c b/libs/console/menu.c index aea52cefc..fd34f6a68 100644 --- a/libs/console/menu.c +++ b/libs/console/menu.c @@ -599,7 +599,7 @@ Menu_Init (void) menu_hash = Hash_NewTable (61, menu_get_key, menu_free, 0, 0); - PR_RegisterBuiltins (&menu_pr_state, builtins); + PR_RegisterBuiltins (&menu_pr_state, builtins, 0); RUA_Init (&menu_pr_state, 3); diff --git a/libs/gamecode/pr_builtins.c b/libs/gamecode/pr_builtins.c index 150b43932..ab5088b9b 100644 --- a/libs/gamecode/pr_builtins.c +++ b/libs/gamecode/pr_builtins.c @@ -102,7 +102,7 @@ bi_no_function (progs_t *pr) } VISIBLE void -PR_RegisterBuiltins (progs_t *pr, builtin_t *builtins) +PR_RegisterBuiltins (progs_t *pr, builtin_t *builtins, void *data) { builtin_t *bi; int count; @@ -135,21 +135,25 @@ PR_RegisterBuiltins (progs_t *pr, builtin_t *builtins) builtins = bi; while (builtins->name) { - if (builtins->binum == 0 || builtins->binum >= PR_AUTOBUILTIN) + if (builtins->binum == 0 || builtins->binum >= PR_AUTOBUILTIN) { PR_Error (pr, "bad builtin number: %s = #%d", builtins->name, builtins->binum); + } - if (builtins->binum < 0) + if (builtins->binum < 0) { builtins->binum = builtin_next (pr); + } if ((bi = Hash_Find (pr->builtin_hash, builtins->name)) - || (bi = Hash_FindElement (pr->builtin_num_hash, builtins))) + || (bi = Hash_FindElement (pr->builtin_num_hash, builtins))) { PR_Error (pr, "builtin %s = #%d already defined (%s = #%d)", builtins->name, builtins->binum, bi->name, bi->binum); + } Hash_Add (pr->builtin_hash, builtins); Hash_AddElement (pr->builtin_num_hash, builtins); + builtins->data = data; builtins++; } @@ -231,6 +235,9 @@ PR_RelocateBuiltins (progs_t *pr) } func->first_statement = desc->first_statement; func->func = proc; + if (bi) { + func->data = bi->data; + } } if (bad) { Sys_Printf ("PR_RelocateBuiltins: %s: progs may not work due to " diff --git a/libs/gib/bi_gib.c b/libs/gib/bi_gib.c index 28d5401c0..8c0deb4e8 100644 --- a/libs/gib/bi_gib.c +++ b/libs/gib/bi_gib.c @@ -193,11 +193,10 @@ GIB_Progs_Init (progs_t *pr) bi_gib_resources_t *res = malloc (sizeof (bi_gib_resources_t)); res->builtins = 0; - PR_Resources_Register (pr, "GIB", res, bi_gib_builtin_clear); - bi_gib_builtins = Hash_NewTable (1021, bi_gib_builtin_get_key, bi_gib_builtin_free, 0, pr->hashlink_freelist); - PR_RegisterBuiltins (pr, builtins); + PR_Resources_Register (pr, "GIB", res, bi_gib_builtin_clear); + PR_RegisterBuiltins (pr, builtins, res); } diff --git a/libs/ruamoko/pr_cmds.c b/libs/ruamoko/pr_cmds.c index 7c70b82d6..24d3f6294 100644 --- a/libs/ruamoko/pr_cmds.c +++ b/libs/ruamoko/pr_cmds.c @@ -628,5 +628,5 @@ static builtin_t builtins[] = { VISIBLE void PR_Cmds_Init (progs_t *pr) { - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, 0); } diff --git a/libs/ruamoko/rua_cbuf.c b/libs/ruamoko/rua_cbuf.c index 0a3870d80..7f96f4783 100644 --- a/libs/ruamoko/rua_cbuf.c +++ b/libs/ruamoko/rua_cbuf.c @@ -109,7 +109,7 @@ RUA_Cbuf_Init (progs_t *pr, int secure) { cbuf_resources_t *res = calloc (sizeof (cbuf_resources_t), 1); PR_Resources_Register (pr, "Cbuf", res, bi_cbuf_clear); - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); } VISIBLE void diff --git a/libs/ruamoko/rua_cmd.c b/libs/ruamoko/rua_cmd.c index 8be474e50..c325e3c3a 100644 --- a/libs/ruamoko/rua_cmd.c +++ b/libs/ruamoko/rua_cmd.c @@ -161,11 +161,11 @@ RUA_Cmd_Init (progs_t *pr, int secure) cmd_resources_t *res = calloc (1, sizeof (cmd_resources_t)); res->cmds = 0; - PR_Resources_Register (pr, "Cmd", res, bi_cmd_clear); if (!bi_cmds) bi_cmds = Hash_NewTable (1021, bi_cmd_get_key, bi_cmd_free, 0, pr->hashlink_freelist); - PR_RegisterBuiltins (pr, builtins); + PR_Resources_Register (pr, "Cmd", res, bi_cmd_clear); + PR_RegisterBuiltins (pr, builtins, res); } diff --git a/libs/ruamoko/rua_cvar.c b/libs/ruamoko/rua_cvar.c index 4cf68ee4f..12cc3fca1 100644 --- a/libs/ruamoko/rua_cvar.c +++ b/libs/ruamoko/rua_cvar.c @@ -257,6 +257,5 @@ RUA_Cvar_Init (progs_t *pr, int secure) res->aliases = 0; PR_Resources_Register (pr, "Cvar", res, bi_cvar_clear); - - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); } diff --git a/libs/ruamoko/rua_hash.c b/libs/ruamoko/rua_hash.c index a1b277706..c2cf1f8f7 100644 --- a/libs/ruamoko/rua_hash.c +++ b/libs/ruamoko/rua_hash.c @@ -389,5 +389,5 @@ RUA_Hash_Init (progs_t *pr, int secure) res->tabs = 0; PR_Resources_Register (pr, "Hash", res, bi_hash_clear); - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); } diff --git a/libs/ruamoko/rua_input.c b/libs/ruamoko/rua_input.c index e93d88085..e54dc73e2 100644 --- a/libs/ruamoko/rua_input.c +++ b/libs/ruamoko/rua_input.c @@ -497,17 +497,17 @@ void RUA_Input_Init (progs_t *pr, int secure) { input_resources_t *res = calloc (sizeof (input_resources_t), 1); - PR_Resources_Register (pr, "input", res, bi_input_clear); res->cookie_super = new_memsuper (); res->cookies = Hash_NewTable (251, 0, rua_in_free_cookie, res, &res->hash_links); Hash_SetHashCompare (res->cookies, rua_in_hash_cookie, rua_in_cmp_cookies); + PR_Resources_Register (pr, "input", res, bi_input_clear); if (secure & 2) { - PR_RegisterBuiltins (pr, secure_builtins); + PR_RegisterBuiltins (pr, secure_builtins, res); } else { - PR_RegisterBuiltins (pr, insecure_builtins); + PR_RegisterBuiltins (pr, insecure_builtins, res); } - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); } diff --git a/libs/ruamoko/rua_keys.c b/libs/ruamoko/rua_keys.c index 2f09ae227..d6e9acaa8 100644 --- a/libs/ruamoko/rua_keys.c +++ b/libs/ruamoko/rua_keys.c @@ -181,5 +181,5 @@ static builtin_t builtins[] = { void RUA_Key_Init (progs_t *pr) { - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, 0); } diff --git a/libs/ruamoko/rua_math.c b/libs/ruamoko/rua_math.c index 21d96fb6d..2d7e09398 100644 --- a/libs/ruamoko/rua_math.c +++ b/libs/ruamoko/rua_math.c @@ -375,5 +375,5 @@ static builtin_t builtins[] = { void RUA_Math_Init (progs_t *pr, int secure) { - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, 0); } diff --git a/libs/ruamoko/rua_mersenne.c b/libs/ruamoko/rua_mersenne.c index 200b56785..c55c495c1 100644 --- a/libs/ruamoko/rua_mersenne.c +++ b/libs/ruamoko/rua_mersenne.c @@ -163,5 +163,5 @@ RUA_Mersenne_Init (progs_t *pr, int secure) mtwist_resources_t *res = calloc (1, sizeof (mtwist_resources_t)); PR_Resources_Register (pr, "Mersenne Twister", res, bi_mtwist_clear); - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); } diff --git a/libs/ruamoko/rua_msgbuf.c b/libs/ruamoko/rua_msgbuf.c index 5d28bf53c..c2420ed99 100644 --- a/libs/ruamoko/rua_msgbuf.c +++ b/libs/ruamoko/rua_msgbuf.c @@ -448,5 +448,5 @@ RUA_MsgBuf_Init (progs_t *pr, int secure) msgbuf_resources_t *res = calloc (sizeof (msgbuf_resources_t), 1); PR_Resources_Register (pr, "MsgBuf", res, bi_msgbuf_clear); - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); } diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index 819f9c3c8..2fe0b85f7 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -2245,8 +2245,7 @@ RUA_Obj_Init (progs_t *pr, int secure) load_methods_compare); PR_Resources_Register (pr, "RUA_ObjectiveQuakeC", probj, rua_obj_cleanup); - - PR_RegisterBuiltins (pr, obj_methods); + PR_RegisterBuiltins (pr, obj_methods, probj); PR_AddLoadFunc (pr, rua_obj_init_runtime); } diff --git a/libs/ruamoko/rua_plist.c b/libs/ruamoko/rua_plist.c index 1f27c6b74..4aae2db06 100644 --- a/libs/ruamoko/rua_plist.c +++ b/libs/ruamoko/rua_plist.c @@ -479,5 +479,5 @@ RUA_Plist_Init (progs_t *pr, int secure) Hash_SetHashCompare (res->plist_tab, plist_get_hash, plist_compare); PR_Resources_Register (pr, "plist", res, bi_plist_clear); - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); } diff --git a/libs/ruamoko/rua_qfile.c b/libs/ruamoko/rua_qfile.c index afe23a4e7..1fee454dc 100644 --- a/libs/ruamoko/rua_qfile.c +++ b/libs/ruamoko/rua_qfile.c @@ -390,9 +390,9 @@ RUA_QFile_Init (progs_t *pr, int secure) PR_Resources_Register (pr, "QFile", res, bi_qfile_clear); if (secure) { - PR_RegisterBuiltins (pr, secure_builtins); + PR_RegisterBuiltins (pr, secure_builtins, res); } else { - PR_RegisterBuiltins (pr, insecure_builtins); + PR_RegisterBuiltins (pr, insecure_builtins, res); } - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); } diff --git a/libs/ruamoko/rua_qfs.c b/libs/ruamoko/rua_qfs.c index 9c34d6abe..8f36c4528 100644 --- a/libs/ruamoko/rua_qfs.c +++ b/libs/ruamoko/rua_qfs.c @@ -206,5 +206,5 @@ static builtin_t builtins[] = { void RUA_QFS_Init (progs_t *pr, int secure) { - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, 0); } diff --git a/libs/ruamoko/rua_runtime.c b/libs/ruamoko/rua_runtime.c index 54b67b205..5a1c906ad 100644 --- a/libs/ruamoko/rua_runtime.c +++ b/libs/ruamoko/rua_runtime.c @@ -80,5 +80,5 @@ static builtin_t builtins[] = { void RUA_Runtime_Init (progs_t *pr, int secure) { - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, 0); } diff --git a/libs/ruamoko/rua_script.c b/libs/ruamoko/rua_script.c index 4a90a99e3..8cafdb387 100644 --- a/libs/ruamoko/rua_script.c +++ b/libs/ruamoko/rua_script.c @@ -207,6 +207,5 @@ RUA_Script_Init (progs_t *pr, int secure) script_resources_t *res = calloc (1, sizeof (script_resources_t)); PR_Resources_Register (pr, "Script", res, bi_script_clear); - - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); } diff --git a/libs/ruamoko/rua_set.c b/libs/ruamoko/rua_set.c index 647f7716b..b1b3a7dee 100644 --- a/libs/ruamoko/rua_set.c +++ b/libs/ruamoko/rua_set.c @@ -747,5 +747,5 @@ RUA_Set_Init (progs_t *pr, int secure) res->sets = 0; PR_Resources_Register (pr, "Set", res, res_set_clear); - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); } diff --git a/libs/ruamoko/rua_stdlib.c b/libs/ruamoko/rua_stdlib.c index 19dd7bc7e..fa8489d1c 100644 --- a/libs/ruamoko/rua_stdlib.c +++ b/libs/ruamoko/rua_stdlib.c @@ -171,5 +171,5 @@ static builtin_t builtins[] = { void RUA_Stdlib_Init (progs_t *pr, int secure) { - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, 0); } diff --git a/libs/ruamoko/rua_string.c b/libs/ruamoko/rua_string.c index 21006ac42..e01ab9716 100644 --- a/libs/ruamoko/rua_string.c +++ b/libs/ruamoko/rua_string.c @@ -309,5 +309,5 @@ static builtin_t builtins[] = { void RUA_String_Init (progs_t *pr, int secure) { - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, 0); } diff --git a/libs/video/renderer/r_progs.c b/libs/video/renderer/r_progs.c index 2fbaa6e28..87cd3e513 100644 --- a/libs/video/renderer/r_progs.c +++ b/libs/video/renderer/r_progs.c @@ -353,5 +353,5 @@ R_Progs_Init (progs_t *pr) pr->hashlink_freelist); PR_Resources_Register (pr, "Draw", res, bi_draw_clear); - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); } diff --git a/nq/source/sv_pr_cmds.c b/nq/source/sv_pr_cmds.c index 5c98aa5d9..38755c8f9 100644 --- a/nq/source/sv_pr_cmds.c +++ b/nq/source/sv_pr_cmds.c @@ -1564,5 +1564,5 @@ SV_PR_Cmds_Init () PR_Cmds_Init (&sv_pr_state); - PR_RegisterBuiltins (&sv_pr_state, builtins); + PR_RegisterBuiltins (&sv_pr_state, builtins, 0); } diff --git a/qw/source/sv_pr_cmds.c b/qw/source/sv_pr_cmds.c index fd4841d7a..9e3ffac8f 100644 --- a/qw/source/sv_pr_cmds.c +++ b/qw/source/sv_pr_cmds.c @@ -2070,5 +2070,5 @@ SV_PR_Cmds_Init () bi = PR_FindBuiltin (&sv_pr_state, "cvar"); bi->proc = PF_sv_cvar; - PR_RegisterBuiltins (&sv_pr_state, builtins); + PR_RegisterBuiltins (&sv_pr_state, builtins, 0); } diff --git a/qw/source/sv_pr_cpqw.c b/qw/source/sv_pr_cpqw.c index 160fb090c..32e82e7b9 100644 --- a/qw/source/sv_pr_cpqw.c +++ b/qw/source/sv_pr_cpqw.c @@ -855,6 +855,6 @@ cpqw_load (progs_t *pr) void SV_PR_CPQW_Init (progs_t *pr) { - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, 0); PR_AddLoadFunc (pr, cpqw_load); } diff --git a/qw/source/sv_pr_qwe.c b/qw/source/sv_pr_qwe.c index 521bb721d..c67f695fc 100644 --- a/qw/source/sv_pr_qwe.c +++ b/qw/source/sv_pr_qwe.c @@ -589,6 +589,6 @@ qwe_load (progs_t *pr) void SV_PR_QWE_Init (progs_t *pr) { - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, 0); PR_AddLoadFunc (pr, qwe_load); } diff --git a/qw/source/sv_user.c b/qw/source/sv_user.c index 1160f673a..126c84ef8 100644 --- a/qw/source/sv_user.c +++ b/qw/source/sv_user.c @@ -2012,7 +2012,7 @@ SV_UserInit (void) { ucmd_table = Hash_NewTable (251, ucmds_getkey, ucmds_free, 0, 0); Hash_SetHashCompare (ucmd_table, ucmd_get_hash, ucmd_compare); - PR_RegisterBuiltins (&sv_pr_state, builtins); + PR_RegisterBuiltins (&sv_pr_state, builtins, 0); cl_rollspeed = Cvar_Get ("cl_rollspeed", "200", CVAR_NONE, NULL, "How quickly a player straightens out after " "strafing"); diff --git a/ruamoko/qwaq/builtins/curses.c b/ruamoko/qwaq/builtins/curses.c index a3f83fceb..dfd3d1e40 100644 --- a/ruamoko/qwaq/builtins/curses.c +++ b/ruamoko/qwaq/builtins/curses.c @@ -1957,6 +1957,6 @@ BI_Curses_Init (progs_t *pr) qwaq_init_pipe (&res->results); PR_Resources_Register (pr, "curses", res, bi_curses_clear); - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); Sys_RegisterShutdown (bi_shutdown, pr); } diff --git a/ruamoko/qwaq/builtins/debug.c b/ruamoko/qwaq/builtins/debug.c index 98c7294c7..c9da1e923 100644 --- a/ruamoko/qwaq/builtins/debug.c +++ b/ruamoko/qwaq/builtins/debug.c @@ -688,7 +688,7 @@ QWAQ_Debug_Init (progs_t *pr) PR_AddLoadFunc (pr, qwaq_debug_load); PR_Resources_Register (pr, "qwaq-debug", debug, qwaq_debug_clear); - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, debug); } void diff --git a/ruamoko/qwaq/builtins/editbuffer.c b/ruamoko/qwaq/builtins/editbuffer.c index db3237a2e..3a8fbdf3a 100644 --- a/ruamoko/qwaq/builtins/editbuffer.c +++ b/ruamoko/qwaq/builtins/editbuffer.c @@ -1066,5 +1066,5 @@ QWAQ_EditBuffer_Init (progs_t *pr) res->pr = pr; PR_Resources_Register (pr, "qwaq-editbuffer", res, qwaq_ebresources_clear); - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); } diff --git a/ruamoko/qwaq/builtins/graphics.c b/ruamoko/qwaq/builtins/graphics.c index cd523b20a..746332cc4 100644 --- a/ruamoko/qwaq/builtins/graphics.c +++ b/ruamoko/qwaq/builtins/graphics.c @@ -151,7 +151,7 @@ BI_Graphics_Init (progs_t *pr) qwaq_thread_t *thread = PR_Resources_Find (pr, "qwaq_thread"); byte *basepal, *colormap; - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, 0); QFS_Init (thread->hunk, "nq"); PI_Init (); diff --git a/ruamoko/qwaq/builtins/main.c b/ruamoko/qwaq/builtins/main.c index 955195b65..0215ced3f 100644 --- a/ruamoko/qwaq/builtins/main.c +++ b/ruamoko/qwaq/builtins/main.c @@ -184,7 +184,7 @@ static builtin_t common_builtins[] = { static void common_builtins_init (progs_t *pr) { - PR_RegisterBuiltins (pr, common_builtins); + PR_RegisterBuiltins (pr, common_builtins, 0); } static void diff --git a/ruamoko/qwaq/builtins/term-input.c b/ruamoko/qwaq/builtins/term-input.c index e8d136855..8b34a22e5 100644 --- a/ruamoko/qwaq/builtins/term-input.c +++ b/ruamoko/qwaq/builtins/term-input.c @@ -916,6 +916,6 @@ BI_TermInput_Init (progs_t *pr) qwaq_init_cond (&res->events.cond); PR_Resources_Register (pr, "input", res, bi_input_clear); - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, res); Sys_RegisterShutdown (bi_input_shutdown, pr); } diff --git a/tools/qfcc/test/test-bi.c b/tools/qfcc/test/test-bi.c index 58b1e28d2..5e6a093ef 100644 --- a/tools/qfcc/test/test-bi.c +++ b/tools/qfcc/test/test-bi.c @@ -110,5 +110,5 @@ static builtin_t builtins[] = { void BI_Init (progs_t *pr) { - PR_RegisterBuiltins (pr, builtins); + PR_RegisterBuiltins (pr, builtins, 0); } From 1f802716e1685467d1451920241b580f36cd6426 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 24 Jan 2022 12:48:02 +0900 Subject: [PATCH 210/360] [qfcc] Pass initialize_def the symtab to use as a parameter This takes care of an old FIXME. --- tools/qfcc/include/def.h | 4 +++- tools/qfcc/source/def.c | 25 +++++++++++++------------ tools/qfcc/source/expr_obj.c | 3 ++- tools/qfcc/source/function.c | 10 +++------- tools/qfcc/source/qc-parse.y | 17 +++++++++++------ tools/qfcc/source/qp-parse.y | 6 ++++-- tools/qfcc/source/switch.c | 4 +++- 7 files changed, 39 insertions(+), 30 deletions(-) diff --git a/tools/qfcc/include/def.h b/tools/qfcc/include/def.h index 1477cc7e3..6ecb5aae8 100644 --- a/tools/qfcc/include/def.h +++ b/tools/qfcc/include/def.h @@ -40,6 +40,7 @@ ///@{ struct symbol_s; +struct symtab_s; struct expr_s; /** Represent a memory location that holds a QuakeC/Ruamoko object. @@ -242,10 +243,11 @@ void def_to_ddef (def_t *def, ddef_t *ddef, int aux); \param init If not null, the expressions to use to initialize the def. \param space The space from which to allocate space for the def. \param storage The storage class of the def. + \param symtab The symbol table into which the def will be placed. */ void initialize_def (struct symbol_s *sym, struct expr_s *init, struct defspace_s *space, - storage_class_t storage); + storage_class_t storage, struct symtab_s *symtab); /** Determine if two defs overlap. diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c index 2cc92d4aa..8472e1df4 100644 --- a/tools/qfcc/source/def.c +++ b/tools/qfcc/source/def.c @@ -412,7 +412,7 @@ init_elements (struct def_s *def, expr_t *eles) } static void -init_vector_components (symbol_t *vector_sym, int is_field) +init_vector_components (symbol_t *vector_sym, int is_field, symtab_t *symtab) { expr_t *vector_expr; int i; @@ -425,9 +425,9 @@ init_vector_components (symbol_t *vector_sym, int is_field) const char *name; name = va (0, "%s_%s", vector_sym->name, fields[i]); - sym = symtab_lookup (current_symtab, name); + sym = symtab_lookup (symtab, name); if (sym) { - if (sym->table == current_symtab) { + if (sym->table == symtab) { if (sym->sy_type != sy_expr) { error (0, "%s redefined", name); sym = 0; @@ -461,12 +461,13 @@ init_vector_components (symbol_t *vector_sym, int is_field) sym->sy_type = sy_expr; sym->s.expr = expr; if (!sym->table) - symtab_addsymbol (current_symtab, sym); + symtab_addsymbol (symtab, sym); } } static void -init_field_def (def_t *def, expr_t *init, storage_class_t storage) +init_field_def (def_t *def, expr_t *init, storage_class_t storage, + symtab_t *symtab) { type_t *type = (type_t *) dereference_type (def->type);//FIXME cast def_t *field_def; @@ -499,7 +500,7 @@ init_field_def (def_t *def, expr_t *init, storage_class_t storage) } // no support for initialized field vector componets (yet?) if (is_vector(type) && options.code.vector_components) - init_vector_components (field_sym, 1); + init_vector_components (field_sym, 1, symtab); } else if (init->type == ex_symbol) { symbol_t *sym = init->e.symbol; symbol_t *field = symtab_lookup (pr.entity_fields, sym->name); @@ -523,12 +524,12 @@ num_elements (expr_t *e) void initialize_def (symbol_t *sym, expr_t *init, defspace_t *space, - storage_class_t storage) + storage_class_t storage, symtab_t *symtab) { - symbol_t *check = symtab_lookup (current_symtab, sym->name); + symbol_t *check = symtab_lookup (symtab, sym->name); reloc_t *relocs = 0; - if (check && check->table == current_symtab) { + if (check && check->table == symtab) { if (check->sy_type != sy_var || !type_same (check->type, sym->type)) { error (0, "%s redefined", sym->name); } else { @@ -549,7 +550,7 @@ initialize_def (symbol_t *sym, expr_t *init, defspace_t *space, } sym->sy_type = sy_var; if (!sym->table) - symtab_addsymbol (current_symtab, sym); + symtab_addsymbol (symtab, sym); if (sym->s.def && sym->s.def->external) { //FIXME this really is not the right way @@ -567,10 +568,10 @@ initialize_def (symbol_t *sym, expr_t *init, defspace_t *space, reloc_attach_relocs (relocs, &sym->s.def->relocs); } if (is_vector(sym->type) && options.code.vector_components) - init_vector_components (sym, 0); + init_vector_components (sym, 0, symtab); if (sym->type->type == ev_field && storage != sc_local && storage != sc_param) - init_field_def (sym->s.def, init, storage); + init_field_def (sym->s.def, init, storage, symtab); if (storage == sc_extern) { if (init) error (0, "initializing external variable"); diff --git a/tools/qfcc/source/expr_obj.c b/tools/qfcc/source/expr_obj.c index 0e8a8d53e..6a8bedebf 100644 --- a/tools/qfcc/source/expr_obj.c +++ b/tools/qfcc/source/expr_obj.c @@ -156,7 +156,8 @@ super_expr (class_type_t *class_type) sym = symtab_lookup (current_symtab, ".super"); if (!sym || sym->table != current_symtab) { sym = new_symbol_type (".super", &type_super); - initialize_def (sym, 0, current_symtab->space, sc_local); + initialize_def (sym, 0, current_symtab->space, sc_local, + current_symtab); } super = new_symbol_expr (sym); diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index ac148bf74..189f6cf90 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -494,7 +494,6 @@ build_scope (symbol_t *fsym, symtab_t *parent) symbol_t *param; symtab_t *parameters; symtab_t *locals; - symtab_t *cs = current_symtab;//FIXME check_function (fsym); @@ -508,8 +507,6 @@ build_scope (symbol_t *fsym, symtab_t *parent) locals->space = defspace_new (ds_virtual); fsym->s.func->locals = locals; - current_symtab = locals;//FIXME - if (!fsym->s.func) { internal_error (0, "function %s not defined", fsym->name); } @@ -518,7 +515,7 @@ build_scope (symbol_t *fsym, symtab_t *parent) } if (fsym->s.func->type->t.func.num_params < 0) { args = new_symbol_type (".args", &type_va_list); - initialize_def (args, 0, parameters->space, sc_param); + initialize_def (args, 0, parameters->space, sc_param, locals); } for (p = fsym->params, i = 0; p; p = p->next) { @@ -531,18 +528,17 @@ build_scope (symbol_t *fsym, symtab_t *parent) p->name = save_string (""); } param = new_symbol_type (p->name, p->type); - initialize_def (param, 0, parameters->space, sc_param); + initialize_def (param, 0, parameters->space, sc_param, locals); i++; } if (args) { while (i < PR_MAX_PARAMS) { param = new_symbol_type (va (0, ".par%d", i), &type_param); - initialize_def (param, 0, parameters->space, sc_param); + initialize_def (param, 0, parameters->space, sc_param, locals); i++; } } - current_symtab = cs; } function_t * diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index c0d7d93c0..709470e0c 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -554,7 +554,8 @@ external_decl $1->type=find_type (alias_type ($1->type, $1->type, $1->name)); symtab_addsymbol (current_symtab, $1); } else { - initialize_def ($1, 0, current_symtab->space, spec.storage); + initialize_def ($1, 0, current_symtab->space, spec.storage, + current_symtab); if ($1->s.def) $1->s.def->nosave |= spec.nosave; } @@ -570,7 +571,8 @@ external_decl $1->type=find_type (alias_type ($1->type, $1->type, $1->name)); symtab_addsymbol (current_symtab, $1); } else { - initialize_def ($1, $2, current_symtab->space, spec.storage); + initialize_def ($1, $2, current_symtab->space, spec.storage, + current_symtab); if ($1->s.def) $1->s.def->nosave |= spec.nosave; } @@ -1152,7 +1154,7 @@ decl if (sc == sc_static) space = pr.near_data; $1->type = find_type (append_type ($1->type, spec.type)); - initialize_def ($1, $2, space, sc); + initialize_def ($1, $2, space, sc, current_symtab); if ($1->s.def) $1->s.def->nosave |= spec.nosave; } @@ -1214,7 +1216,8 @@ non_code_func if (local_expr) { symbol_t *sym = $0; specifier_t spec = $-1; - initialize_def (sym, $2, current_symtab->space, spec.storage); + initialize_def (sym, $2, current_symtab->space, spec.storage, + current_symtab); if (sym->s.def) sym->s.def->nosave |= spec.nosave; } else { @@ -1235,7 +1238,8 @@ non_code_func if (sym->sy_type == sy_func) make_function (sym, 0, sym->table->space, spec.storage); } else { - initialize_def (sym, 0, current_symtab->space, spec.storage); + initialize_def (sym, 0, current_symtab->space, spec.storage, + current_symtab); if (sym->s.def) sym->s.def->nosave |= spec.nosave; } @@ -1524,7 +1528,8 @@ init_var_decl specifier_t spec = $0; $1->type = find_type (append_type ($1->type, spec.type)); $1->sy_type = sy_var; - initialize_def ($1, 0, current_symtab->space, spec.storage); + initialize_def ($1, 0, current_symtab->space, spec.storage, + current_symtab); $$ = assign_expr (new_symbol_expr ($1), $2); } ; diff --git a/tools/qfcc/source/qp-parse.y b/tools/qfcc/source/qp-parse.y index a36f27910..db0274ce4 100644 --- a/tools/qfcc/source/qp-parse.y +++ b/tools/qfcc/source/qp-parse.y @@ -199,7 +199,8 @@ program_head { symbol_t *sym = new_symbol ("ExitCode"); sym->type = &type_int; - initialize_def (sym, 0, current_symtab->space, sc_global); + initialize_def (sym, 0, current_symtab->space, sc_global, + current_symtab); if (sym->s.def) { sym->s.def->nosave = 1; } @@ -234,7 +235,8 @@ declarations while ($3) { symbol_t *next = $3->next; $3->type = $5; - initialize_def ($3, 0, current_symtab->space, current_storage); + initialize_def ($3, 0, current_symtab->space, current_storage, + current_symtab); $3 = next; } } diff --git a/tools/qfcc/source/switch.c b/tools/qfcc/source/switch.c index 9f245807a..10b8dc342 100644 --- a/tools/qfcc/source/switch.c +++ b/tools/qfcc/source/switch.c @@ -49,6 +49,7 @@ #include "tools/qfcc/include/options.h" #include "tools/qfcc/include/qfcc.h" #include "tools/qfcc/include/reloc.h" +#include "tools/qfcc/include/shared.h" #include "tools/qfcc/include/switch.h" #include "tools/qfcc/include/symtab.h" #include "tools/qfcc/include/type.h" @@ -348,7 +349,8 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val, table_sym = new_symbol_type (table_name, array_type (&type_int, high - low + 1)); - initialize_def (table_sym, table_init, pr.near_data, sc_static); + initialize_def (table_sym, table_init, pr.near_data, sc_static, + current_symtab); table_expr = new_symbol_expr (table_sym); if (tree->left) { From 00b7bced7f5d5c869e0064245e08dc730ff4b3c9 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 24 Jan 2022 12:50:15 +0900 Subject: [PATCH 211/360] [gamecode] Rework PR_RESET_PARAMS to use PR_SetupParams PR_SetupParams is new and sets up the parameter pointers so older code that expects only up to 8 parameter will work with both v6p and Ruamoko progs without having to check what progs are running. PR_SetupParams is useful even when Ruamoko progs are expected as it reserves the required space (respecting alignment) on the stack and returns a pointer to the top (bottom? confusing) of the stack. PR_PushFrame and PR_PopFrame need to be used around PR_SetupParams, regardless of using temp strings, to avoid a stack leak (need to do an audit). --- include/QF/progs.h | 42 +++++++++++++++++++++++++++++++++++------ libs/gamecode/pr_exec.c | 33 ++++++++++++++++++++++++++++++++ 2 files changed, 69 insertions(+), 6 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 066a479af..78e9913c9 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -82,15 +82,13 @@ void PR_RunError (progs_t *pr, const char *error, ...) __attribute__((format(PRI \warning Failure to use this macro before assigning to the P_* macros can cause corruption of the VM data due to "register" based calling. Can be safely ignored for parameterless functions, or forwarding parameters - though a builtin. + though a builtin. However, it is ok (and encouraged) to call + PR_SetupParams instead, as this macro calls PR_SetupParams with + PR_MAX_PARAMS and 1 for the alignment. \hideinitializer */ -#define PR_RESET_PARAMS(pr) \ - do { \ - (pr)->pr_params[0] = (pr)->pr_real_params[0]; \ - (pr)->pr_params[1] = (pr)->pr_real_params[1]; \ - } while (0) +#define PR_RESET_PARAMS(pr) PR_SetupParams (pr, PR_MAX_PARAMS, 1) /** \name Detouring Function Calls @@ -155,6 +153,38 @@ void PR_RestoreParams (progs_t *pr, pr_stashed_params_t *params); */ void PR_PushFrame (progs_t *pr); +/** Reserve space on the data stack and set up the param pointers. + + For v6p progs, this only sets up the param pointers as v6p progs do not + have a data stack. + + For Ruamoko progs, space for at least \a num_params (each being 4 words) + is created on the stack, with a minimum alignment of min_alignment words, + or 4, whichever is larger. + + \param pr pointer to ::progs_t VM struct + \param num_params Number of parameter slots needed for the function call. + Each slot is 4 words. dvec4 and lvec4 parameters require + 8 words and must be 8-word aligned. dvec3 and lvec3 + also require 8 words due to the minimum 4 word alignment, + but have no alignment requirements themselves. Be sure to + take this into account in size calculations. + \param min_alignment Minimum number of words to which the stack will be + aligned. Must be a power of two. Note that when passing + dvec4 or lvec4 parameters, they have a hardware-enforced + requirement of 8 word alignment. This means that for + something like (int, lvec4), there will be an unused + parameter slot between the int and the lvec4. + Ignored for v6p progs. + \return Pointer to the base of the created parameter area. For + v6p progs, this is just .param_0, but for Ruamoko progs + this will be the current top of the the data stack after + adjustment for the parameter space. + \note Attempting to pass more than PR_MAX_PARAMS parameters to v6p progs + is a hard error. +*/ +pr_type_t *PR_SetupParams (progs_t *pr, int num_params, int min_alignment); + /** Pop an execution frame from the VM stack. Restores execution state. Also frees any temporary strings allocated in this frame (via PR_FreeTempStrings()). diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 19507665c..a78b01f9a 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -458,6 +458,9 @@ PR_CallFunction (progs_t *pr, pr_func_t fnum, pr_type_t *return_ptr) static void check_stack_pointer (progs_t *pr, pr_ptr_t stack, int size) { + if (stack & 3) { + PR_RunError (pr, "Progs stack not aligned"); + } if (stack < pr->stack_bottom) { PR_RunError (pr, "Progs stack overflow"); } @@ -466,6 +469,36 @@ check_stack_pointer (progs_t *pr, pr_ptr_t stack, int size) } } +VISIBLE pr_type_t * +PR_SetupParams (progs_t *pr, int num_params, int min_alignment) +{ + if (pr->progs->version < PROG_VERSION) { + if (num_params > PR_MAX_PARAMS) { + PR_Error (pr, "attempt to settup more than %d params", + PR_MAX_PARAMS); + } + pr->pr_params[0] = pr->pr_real_params[0]; + pr->pr_params[1] = pr->pr_real_params[1]; + return pr->pr_real_params[0]; + } + int offset = num_params * 4; + if (min_alignment < 4) { + min_alignment = 4; + } + pr_ptr_t mask = ~(min_alignment - 1); + pr_ptr_t stack = (*pr->globals.stack - offset) & mask; + if (pr_boundscheck->int_val) { + check_stack_pointer (pr, stack, 0); + } + *pr->globals.stack = stack; + pr->pr_params[0] = pr->pr_globals + stack; + num_params = min (num_params, PR_MAX_PARAMS); + for (int i = 1; i < num_params; i++) { + pr->pr_params[i] = pr->pr_params[0] + i * 4; + } + return pr->pr_params[0]; +} + static inline void pr_memset (pr_type_t *dst, int val, pr_uint_t count) { From 739c98fe213734a6711cb10165c30ba8b50c035b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 24 Jan 2022 16:42:13 +0900 Subject: [PATCH 212/360] [qfcc] Add adjstk and with to dot_expr And be more informative with "bad" expression types (print the name if it's just that I haven't added a printer for a valid type). --- tools/qfcc/source/dot_expr.c | 31 +++++++++++++++++++++++++++++-- 1 file changed, 29 insertions(+), 2 deletions(-) diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index 0074aa328..3b918ca12 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -633,6 +633,27 @@ print_memset (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) dasprintf (dstr, "%*se_%p [label=\"memset\"];\n", indent, "", e); } +static void +print_adjstk (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) +{ + int indent = level * 2 + 2; + + dasprintf (dstr, "%*se_%p [label=\"adjstk %d:%d\\n%d\"];\n", indent, "", e, + e->e.adjstk.mode, e->e.adjstk.offset, e->line); +} + +static void +print_with (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) +{ + int indent = level * 2 + 2; + expr_t *with = e->e.with.with; + + _print_expr (dstr, with, level, id, next); + dasprintf (dstr, "%*se_%p -> \"e_%p\";\n", indent, "", e, with); + dasprintf (dstr, "%*se_%p [label=\"with %d:%d\\n%d\"];\n", indent, "", e, + e->e.with.mode, e->e.with.reg, e->line); +} + static void _print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) { @@ -659,6 +680,8 @@ _print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) [ex_assign] = print_assign, [ex_branch] = print_branch, [ex_return] = print_return, + [ex_adjstk] = print_adjstk, + [ex_with] = print_with, }; int indent = level * 2 + 2; @@ -671,8 +694,12 @@ _print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) e->printid = id; if ((int) e->type < 0 || e->type >= ex_count || !print_funcs[e->type]) { - dasprintf (dstr, "%*se_%p [label=\"(bad expr type)\\n%d\"];\n", - indent, "", e, e->line); + const char *type = va (0, "%d", e->type); + if (e->type >= 0 && e->type < ex_count) { + type = expr_names[e->type]; + } + dasprintf (dstr, "%*se_%p [label=\"(bad expr type: %s)\\n%d\"];\n", + indent, "", e, type, e->line); return; } print_funcs[e->type] (dstr, e, level, id, next); From 9fc8f14be6677fdb2179ee71759cdb031e54666c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 24 Jan 2022 16:44:48 +0900 Subject: [PATCH 213/360] [qfcc] Put the stack frame exprs into the statements block dot_expr doesn't follow an expression's next pointer on its own. make_statements was fine, which is why I didn't notice the mistake until now. --- tools/qfcc/source/expr.c | 22 ++++++++++++++++++++++ tools/qfcc/source/function.c | 6 ++---- 2 files changed, 24 insertions(+), 4 deletions(-) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index c0b291789..48476ab89 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1419,6 +1419,28 @@ append_expr (expr_t *block, expr_t *e) return block; } +expr_t * +prepend_expr (expr_t *block, expr_t *e) +{ + if (block->type != ex_block) + internal_error (block, "not a block expression"); + + if (!e || e->type == ex_error) + return block; + + if (e->next) + internal_error (e, "append_expr: expr loop detected"); + + e->next = block->e.block.head; + block->e.block.head = e; + + if (block->e.block.tail == &block->e.block.head) { + block->e.block.tail = &e->next; + } + + return block; +} + static symbol_t * get_struct_field (const type_t *t1, expr_t *e1, expr_t *e2) { diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index 189f6cf90..82982b955 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -677,16 +677,14 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements) if (options.code.progsversion == PROG_VERSION) { expr_t *e; e = new_with_expr (2, LOCALS_REG, new_short_expr (0)); - e->next = statements; e->file = func->def->file; e->line = func->def->line; - statements = e; + prepend_expr (statements, e); e = new_adjstk_expr (0, 0); - e->next = statements; e->file = func->def->file; e->line = func->def->line; - statements = e; + prepend_expr (statements, e); func->temp_reg = LOCALS_REG; for (def_t *def = func->locals->space->defs; def; def = def->next) { From b663fecd4ea5f4dcfe79af38625247f0329efacb Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 24 Jan 2022 16:46:49 +0900 Subject: [PATCH 214/360] [gamecode] Use PR_SetupParameters for rua called builtins It's a bit heavy-handed as it sets all the param pointers, but simple (no varargs) functions are working nicely in Ruamoko. --- libs/gamecode/pr_exec.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index a78b01f9a..519808418 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -439,6 +439,9 @@ PR_CallFunction (progs_t *pr, pr_func_t fnum, pr_type_t *return_ptr) f = pr->function_table + fnum; if (f->first_statement < 0) { // negative statements are built in functions + if (pr->progs->version == PROG_VERSION) { + PR_SetupParams (pr, 0, 0); + } if (pr->pr_trace && !pr->debug_handler) { Sys_Printf ("Calling builtin %s @ %p\n", PR_GetString (pr, f->descriptor->name), f->func); From 5cf79243529ea770d5ee465f6baa026786e76a94 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 24 Jan 2022 16:50:15 +0900 Subject: [PATCH 215/360] [qfcc] Improve dags handling of auxiliary use ops The aux use ops need to be counted and given nodes explicitly as they may refer to defs that are not accessed by other statements other than by aliases, and those aliases need to be marked live as well as the used def. --- tools/qfcc/source/dags.c | 30 +++++++++++++++++++++++++----- 1 file changed, 25 insertions(+), 5 deletions(-) diff --git a/tools/qfcc/source/dags.c b/tools/qfcc/source/dags.c index a128422cc..ac3a36a63 100644 --- a/tools/qfcc/source/dags.c +++ b/tools/qfcc/source/dags.c @@ -66,6 +66,8 @@ static dag_t *dags_freelist; static daglabel_t *daglabel_chain; +static void dag_live_aliases(operand_t *op); + static void flush_daglabels (void) { @@ -453,6 +455,7 @@ dagnode_set_edges (dag_t *dag, dagnode_t *n, statement_t *s) } daglabel_t *label = operand_label (dag, use); label->live = 1; + dag_live_aliases (use); set_add (n->edges, label->dagnode->number); } if (n->type == st_func) { @@ -815,6 +818,7 @@ dag_create (flownode_t *flownode) dagnode_t **nodes; daglabel_t **labels; int num_statements = 0; + int num_use = 0; int num_nodes; int num_lables; set_t *live_vars = set_new (); @@ -823,18 +827,25 @@ dag_create (flownode_t *flownode) // count the number of statements so the number of nodes and labels can be // guessed - for (s = block->statements; s; s = s->next) + for (s = block->statements; s; s = s->next) { num_statements++; + for (operand_t *use = s->use; use; use = use->next) { + if (use->op_type == op_pseudo) { + continue; + } + num_use++; + } + } set_assign (live_vars, flownode->live_vars.out); dag = new_dag (); dag->flownode = flownode; - // at most FLOW_OPERANDS per statement - num_nodes = num_statements * FLOW_OPERANDS; + // at most FLOW_OPERANDS per statement + use + num_nodes = num_statements * FLOW_OPERANDS + num_use; dag->nodes = alloca (num_nodes * sizeof (dagnode_t)); - // at most FLOW_OPERANDS per statement, + return + params - num_lables = num_statements * (FLOW_OPERANDS + 1 + 8); + // at most FLOW_OPERANDS per statement, + return + params + use + num_lables = num_statements * (FLOW_OPERANDS + 1 + 8) + num_use; dag->labels = alloca (num_lables * sizeof (daglabel_t)); dag->roots = set_new (); @@ -843,6 +854,15 @@ dag_create (flownode_t *flownode) for (s = block->statements; s; s = s->next) { operand_t *operands[FLOW_OPERANDS]; dag_make_leafs (dag, s, operands); + // make sure any auxiliary operands are given nodes, too + for (operand_t *use = s->use; use; use = use->next) { + if (use->op_type == op_pseudo) { + continue; + } + if (!dag_node (use)) { + leaf_node (dag, use, s->expr); + } + } } // actual dag creation for (s = block->statements; s; s = s->next) { From 7e147e703c9eb18ab72d20a66be361264341ec91 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 24 Jan 2022 18:31:53 +0900 Subject: [PATCH 216/360] [qfcc] Copy def reg into alias def This fixes incorrect local struct member access in Ruamoko progs. --- tools/qfcc/source/def.c | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c index 8472e1df4..44c3d74c6 100644 --- a/tools/qfcc/source/def.c +++ b/tools/qfcc/source/def.c @@ -196,6 +196,7 @@ alias_def (def_t *def, type_t *type, int offset) alias->line = pr.source_line; alias->file = pr.source_file; alias->next = def->alias_defs; + alias->reg = def->reg; def->alias_defs = alias; return alias; } From 37f08f9d4f34decd77b6a07449afe11cee4a5c54 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 24 Jan 2022 18:35:16 +0900 Subject: [PATCH 217/360] [qfcc] Build the Ruamoko function parameters The parameter defs are allocated from the parameter space using a minimum alignment of 4, and varargs functions get a va_list struct in place of the ... An "args" expression is unconditionally injected into the call arguments list at the place where ... is in the list, with arguments passed through ... coming after the ... Arguments get through to functions now, but there's problems with taking the address of local variables: currently done using constant pointer defs, which can't work for the base register addressing used in Ruamoko progs. With the update to test-bi's printf (and a hack to qfcc for lea), triangle.r actually works, printing the expected results (but -1 instead of 1 for equality, though that too is actually expected). qfcc will take a bit longer because it seems there are some design issues in address expressions (ambiguity, and a few other things) that have pretty much always been there. --- libs/gamecode/pr_exec.c | 2 +- tools/qfcc/include/expr.h | 9 ++++ tools/qfcc/include/expr_names.h | 1 + tools/qfcc/source/dot_expr.c | 10 ++++ tools/qfcc/source/expr.c | 42 +++++++++++++-- tools/qfcc/source/expr_assign.c | 1 + tools/qfcc/source/function.c | 96 +++++++++++++++++++++++++-------- tools/qfcc/source/statements.c | 57 ++++++++++++++++++-- tools/qfcc/test/test-bi.c | 13 +++++ 9 files changed, 200 insertions(+), 31 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 519808418..80df7c310 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -495,7 +495,7 @@ PR_SetupParams (progs_t *pr, int num_params, int min_alignment) } *pr->globals.stack = stack; pr->pr_params[0] = pr->pr_globals + stack; - num_params = min (num_params, PR_MAX_PARAMS); + num_params = max (num_params, PR_MAX_PARAMS); for (int i = 1; i < num_params; i++) { pr->pr_params[i] = pr->pr_params[0] + i * 4; } diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index aeb4e86ff..7783a572d 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -488,6 +488,14 @@ expr_t *new_temp_def_expr (const struct type_s *type); */ expr_t *new_nil_expr (void); +/** Create a new args expression node + + Marker between real parameters and those passed through ... + + \return The new args expression node. +*/ +expr_t *new_args_expr (void); + /** Create a new value expression node. \param value The value to put in the expression node. @@ -725,6 +733,7 @@ void convert_name (expr_t *e); expr_t *convert_vector (expr_t *e); expr_t *append_expr (expr_t *block, expr_t *e); +expr_t *prepend_expr (expr_t *block, expr_t *e); expr_t *reverse_expr_list (expr_t *e); void print_expr (expr_t *e); diff --git a/tools/qfcc/include/expr_names.h b/tools/qfcc/include/expr_names.h index 5af4e739b..820ba9826 100644 --- a/tools/qfcc/include/expr_names.h +++ b/tools/qfcc/include/expr_names.h @@ -61,5 +61,6 @@ EX_EXPR(branch) ///< branch expression (::ex_branch_t) EX_EXPR(return) ///< return expression (::ex_return_t) EX_EXPR(adjstk) ///< stack adjust expression (::ex_adjstk_t) EX_EXPR(with) ///< with expression (::ex_with_t) +EX_EXPR(args) ///< @args marker in parameter list. no data ///@} diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index 3b918ca12..687cfb868 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -654,6 +654,15 @@ print_with (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) e->e.with.mode, e->e.with.reg, e->line); } +static void +print_args (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) +{ + int indent = level * 2 + 2; + + dasprintf (dstr, "%*se_%p [label=\"...\\n%d\"];\n", indent, "", e, + e->line); +} + static void _print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) { @@ -682,6 +691,7 @@ _print_expr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) [ex_return] = print_return, [ex_adjstk] = print_adjstk, [ex_with] = print_with, + [ex_args] = print_args, }; int indent = level * 2 + 2; diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 48476ab89..a5740700e 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -274,6 +274,8 @@ get_type (expr_t *e) break; case ex_assign: return get_type (e->e.assign.dst); + case ex_args: + return &type_va_list; case ex_count: internal_error (e, "invalid expression"); } @@ -525,6 +527,10 @@ copy_expr (expr_t *e) *n = *e; n->e.with.with = copy_expr (e->e.with.with); return n; + case ex_args: + n = new_expr (); + *n = *e; + return n; case ex_count: break; } @@ -725,6 +731,14 @@ new_nil_expr (void) return e; } +expr_t * +new_args_expr (void) +{ + expr_t *e = new_expr (); + e->type = ex_args; + return e; +} + expr_t * new_value_expr (ex_value_t *value) { @@ -1709,6 +1723,7 @@ has_function_call (expr_t *e) case ex_memset: case ex_adjstk: case ex_with: + case ex_args: return 0; case ex_count: break; @@ -1803,6 +1818,7 @@ unary_expr (int op, expr_t *e) case ex_return: case ex_adjstk: case ex_with: + case ex_args: internal_error (e, "unexpected expression type"); case ex_uexpr: if (e->e.expr.op == '-') { @@ -1907,6 +1923,7 @@ unary_expr (int op, expr_t *e) case ex_return: case ex_adjstk: case ex_with: + case ex_args: internal_error (e, "unexpected expression type"); case ex_bool: return new_bool_expr (e->e.bool.false_list, @@ -1989,6 +2006,7 @@ unary_expr (int op, expr_t *e) case ex_return: case ex_adjstk: case ex_with: + case ex_args: internal_error (e, "unexpected expression type"); case ex_uexpr: if (e->e.expr.op == '~') @@ -2048,12 +2066,13 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) { expr_t *e; expr_t *p; - int arg_count = 0, parm_count = 0; + int arg_count = 0, param_count = 0; int i; expr_t *args = 0, **a = &args; type_t *arg_types[PR_MAX_PARAMS]; expr_t *arg_exprs[PR_MAX_PARAMS][2]; int arg_expr_count = 0; + int emit_args = 0; expr_t *assign; expr_t *call; expr_t *err = 0; @@ -2074,7 +2093,8 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) if (options.warnings.traditional) warning (fexpr, "too few arguments"); } - parm_count = -ftype->t.func.num_params - 1; + param_count = -ftype->t.func.num_params - 1; + emit_args = 1; } else if (ftype->t.func.num_params >= 0) { if (arg_count > ftype->t.func.num_params) { return error (fexpr, "too many arguments"); @@ -2084,13 +2104,14 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) if (options.warnings.traditional) warning (fexpr, "too few arguments"); } - parm_count = ftype->t.func.num_params; + param_count = ftype->t.func.num_params; } + // params is reversed (a, b, c) -> c, b, a for (i = arg_count - 1, e = params; i >= 0; i--, e = e->next) { type_t *t; if (e->type == ex_compound) { - if (i < parm_count) { + if (i < param_count) { t = ftype->t.func.param_types[i]; } else { return error (e, "cannot pass compound initializer " @@ -2109,7 +2130,7 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) if (type_size (t) > type_size (&type_param)) err = error (e, "formal parameter %d is too large to be passed by" " value", i + 1); - if (i < parm_count) { + if (i < param_count) { if (e->type == ex_nil) convert_nil (e, t = ftype->t.func.param_types[i]); if (e->type == ex_bool) @@ -2154,7 +2175,13 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) call = expr_file_line (new_block_expr (), fexpr); call->e.block.is_call = 1; + // args is built in reverse order so it matches params for (p = params, i = 0; p; p = p->next, i++) { + if (emit_args && arg_count - i == param_count) { + emit_args = 0; + *a = new_args_expr (); + a = &(*a)->next; + } expr_t *e = p; if (e->type == ex_compound) { e = expr_file_line (initialized_temp_expr (arg_types[i], e), e); @@ -2175,6 +2202,11 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) } a = &(*a)->next; } + if (emit_args) { + emit_args = 0; + *a = new_args_expr (); + a = &(*a)->next; + } for (i = 0; i < arg_expr_count - 1; i++) { assign = assign_expr (arg_exprs[i][1], arg_exprs[i][0]); append_expr (call, expr_file_line (assign, arg_exprs[i][0])); diff --git a/tools/qfcc/source/expr_assign.c b/tools/qfcc/source/expr_assign.c index 0926931fb..9aa1f2784 100644 --- a/tools/qfcc/source/expr_assign.c +++ b/tools/qfcc/source/expr_assign.c @@ -140,6 +140,7 @@ is_lvalue (const expr_t *expr) case ex_return: case ex_adjstk: case ex_with: + case ex_args: break; case ex_count: internal_error (expr, "invalid expression"); diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index 82982b955..81a20af46 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -486,33 +486,15 @@ check_function (symbol_t *fsym) } static void -build_scope (symbol_t *fsym, symtab_t *parent) +build_v6p_scope (symbol_t *fsym) { int i; param_t *p; symbol_t *args = 0; symbol_t *param; - symtab_t *parameters; - symtab_t *locals; + symtab_t *parameters = fsym->s.func->parameters; + symtab_t *locals = fsym->s.func->locals; - check_function (fsym); - - fsym->s.func->label_scope = new_symtab (0, stab_local); - - parameters = new_symtab (parent, stab_local); - parameters->space = defspace_new (ds_virtual); - fsym->s.func->parameters = parameters; - - locals = new_symtab (parameters, stab_local); - locals->space = defspace_new (ds_virtual); - fsym->s.func->locals = locals; - - if (!fsym->s.func) { - internal_error (0, "function %s not defined", fsym->name); - } - if (!is_func (fsym->s.func->type)) { - internal_error (0, "function type %s not a funciton", fsym->name); - } if (fsym->s.func->type->t.func.num_params < 0) { args = new_symbol_type (".args", &type_va_list); initialize_def (args, 0, parameters->space, sc_param, locals); @@ -541,6 +523,78 @@ build_scope (symbol_t *fsym, symtab_t *parent) } } +static void +create_param (symtab_t *parameters, symbol_t *param) +{ + defspace_t *space = parameters->space; + def_t *def = new_def (param->name, 0, space, sc_param); + int size = type_size (param->type); + int alignment = param->type->alignment; + if (alignment < 4) { + alignment = 4; + } + def->offset = defspace_alloc_aligned_highwater (space, size, alignment); + def->type = param->type; + param->s.def = def; + param->sy_type = sy_var; + symtab_addsymbol (parameters, param); +} + +static void +build_rua_scope (symbol_t *fsym) +{ + for (param_t *p = fsym->params; p; p = p->next) { + symbol_t *param; + if (!p->selector && !p->type && !p->name) { + // ellipsis marker + param = new_symbol_type (".args", &type_va_list); + } else { + if (!p->type) { + continue; // non-param selector + } + if (!p->name) { + error (0, "parameter name omitted"); + p->name = save_string (""); + } + param = new_symbol_type (p->name, p->type); + } + create_param (fsym->s.func->parameters, param); + param->s.def->reg = fsym->s.func->temp_reg;; + } +} + +static void +build_scope (symbol_t *fsym, symtab_t *parent) +{ + symtab_t *parameters; + symtab_t *locals; + + if (!fsym->s.func) { + internal_error (0, "function %s not defined", fsym->name); + } + if (!is_func (fsym->s.func->type)) { + internal_error (0, "function type %s not a funciton", fsym->name); + } + + check_function (fsym); + + fsym->s.func->label_scope = new_symtab (0, stab_local); + + parameters = new_symtab (parent, stab_local); + parameters->space = defspace_new (ds_virtual); + fsym->s.func->parameters = parameters; + + locals = new_symtab (parameters, stab_local); + locals->space = defspace_new (ds_virtual); + fsym->s.func->locals = locals; + + if (options.code.progsversion == PROG_VERSION) { + build_rua_scope (fsym); + } else { + build_v6p_scope (fsym); + } +} + function_t * new_function (const char *name, const char *nice_name) { diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 1168c3fcf..028ec9e96 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1026,10 +1026,19 @@ expr_call_v6p (sblock_t *sblock, expr_t *call, operand_t **op) statement_t *s; // function arguments are in reverse order - for (a = args; a; a = a->next) + for (a = args; a; a = a->next) { + if (a->type == ex_args) { + // v6p uses callN and pr_argc + continue; + } count++; + } ind = count; for (a = args; a; a = a->next) { + if (a->type == ex_args) { + // v6p uses callN and pr_argc + continue; + } ind--; param = new_param_expr (get_type (a), ind); if (count && options.code.progsversion != PROG_ID_VERSION && ind < 2) { @@ -1091,8 +1100,11 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) defspace_t *arg_space = current_func->arguments; expr_t *func = call->e.branch.target; expr_t *args = call->e.branch.args; + expr_t *args_va_list = 0; // .args (...) parameter + expr_t *args_params = 0; // first arg in ... operand_t *use = 0; operand_t *kill = 0; + int num_params = 0; defspace_reset (arg_space); @@ -1111,9 +1123,21 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) def->offset = defspace_alloc_aligned_highwater (arg_space, size, alignment); def->type = arg_type; - expr_t *assign = assign_expr (new_def_expr (def), a); - expr_file_line (assign, call); - sblock = statement_slist (sblock, assign); + def->reg = current_func->temp_reg; + expr_t *def_expr = expr_file_line (new_def_expr (def), call); + if (a->type == ex_args) { + args_va_list = def_expr; + } else { + if (args_va_list && !args_params) { + args_params = def_expr; + } + if (args_va_list) { + num_params++; + } + expr_t *assign = assign_expr (def_expr, a); + expr_file_line (assign, call); + sblock = statement_slist (sblock, assign); + } // The call both uses and kills the arguments: use is obvious, but kill // is because the callee has direct access to them and might modify @@ -1126,6 +1150,31 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) k->next = kill; kill = k; } + if (args_va_list) { + expr_t *assign; + expr_t *count; + expr_t *list; + expr_t *args_count = field_expr (args_va_list, + new_name_expr ("count")); + expr_t *args_list = field_expr (args_va_list, + new_name_expr ("list")); + expr_file_line (args_count, call); + expr_file_line (args_list, call); + + count = new_short_expr (num_params); + assign = assign_expr (args_count, count); + expr_file_line (assign, call); + sblock = statement_slist (sblock, assign); + + if (args_params) { + list = address_expr (args_params, 0, &type_param); + } else { + list = new_nil_expr (); + } + assign = assign_expr (args_list, list); + expr_file_line (assign, call); + sblock = statement_slist (sblock, assign); + } statement_t *s = new_statement (st_func, "call", call); sblock = statement_subexpr (sblock, func, &s->opa); if (!op) { diff --git a/tools/qfcc/test/test-bi.c b/tools/qfcc/test/test-bi.c index 5e6a093ef..412a341bf 100644 --- a/tools/qfcc/test/test-bi.c +++ b/tools/qfcc/test/test-bi.c @@ -55,6 +55,19 @@ bi_printf (progs_t *pr) else dstring_clear (dstr); + if (pr->progs->version == PROG_VERSION) { + __auto_type va_list = &P_PACKED (pr, pr_va_list_t, 1); + count = va_list->count; + if (count) { + args = alloca (count * sizeof (pr_type_t *)); + for (int i = 0; i < count; i++) { + args[i] = &pr->pr_globals[va_list->list + i * 4]; + } + } else { + args = 0; + } + } + PR_Sprintf (pr, dstr, "bi_printf", fmt, count, args); if (dstr->str) fputs (dstr->str, stdout); From fc73cfc1e0b7d61fd7373e668d57977dc5d33c0b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 25 Jan 2022 12:28:53 +0900 Subject: [PATCH 218/360] [qfcc] Rename pointer_expr to deref_pointer_expr This reflects what it actually does (usually, "pointer_expr" type naming is creating an expression that represents a pointer). --- tools/qfcc/include/expr.h | 2 +- tools/qfcc/source/expr.c | 4 ++-- tools/qfcc/source/qc-parse.y | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 7783a572d..977a018ff 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -766,7 +766,7 @@ expr_t *return_expr (struct function_s *f, expr_t *e); expr_t *conditional_expr (expr_t *cond, expr_t *e1, expr_t *e2); expr_t *incop_expr (int op, expr_t *e, int postop); expr_t *array_expr (expr_t *array, expr_t *index); -expr_t *pointer_expr (expr_t *pointer); +expr_t *deref_pointer_expr (expr_t *pointer); expr_t *address_expr (expr_t *e1, expr_t *e2, struct type_s *t); expr_t *build_if_statement (int not, expr_t *test, expr_t *s1, expr_t *els, expr_t *s2); diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index a5740700e..52b0fbe84 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -2468,7 +2468,7 @@ incop_expr (int op, expr_t *e, int postop) append_expr (block, assign_expr (t2, binary_expr (op, t1, one))); res = copy_expr (e); if (res->type == ex_uexpr && res->e.expr.op == '.') - res = pointer_expr (address_expr (res, 0, 0)); + res = deref_pointer_expr (address_expr (res, 0, 0)); append_expr (block, assign_expr (res, t2)); block->e.block.result = t1; return block; @@ -2531,7 +2531,7 @@ array_expr (expr_t *array, expr_t *index) } expr_t * -pointer_expr (expr_t *pointer) +deref_pointer_expr (expr_t *pointer) { type_t *pointer_type = get_type (pointer); diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index 709470e0c..399f91b1e 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -1560,7 +1560,7 @@ unary_expr | '!' cast_expr %prec UNARY { $$ = unary_expr ('!', $2); } | '~' cast_expr %prec UNARY { $$ = unary_expr ('~', $2); } | '&' cast_expr %prec UNARY { $$ = address_expr ($2, 0, 0); } - | '*' cast_expr %prec UNARY { $$ = pointer_expr ($2); } + | '*' cast_expr %prec UNARY { $$ = deref_pointer_expr ($2); } | SIZEOF unary_expr %prec UNARY { $$ = sizeof_expr ($2, 0); } | SIZEOF '(' abstract_decl ')' %prec HYPERUNARY { From a1acdb895153410567d1b8efc43bb9f37b4bb4c9 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 25 Jan 2022 12:29:15 +0900 Subject: [PATCH 219/360] [qfcc] Print children of uexpr and return expressions It's possible I lost the child printing when creating the return expressions, but dot diagrams are much more useful when they don't have nodes with just pointer values. --- tools/qfcc/source/dot_expr.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index 687cfb868..e5b5e87ea 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -406,6 +406,7 @@ print_return (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) int indent = level * 2 + 2; if (e->e.retrn.ret_val) { + _print_expr (dstr, e->e.retrn.ret_val, level, id, next); dasprintf (dstr, "%*se_%p -> \"e_%p\";\n", indent, "", e, e->e.retrn.ret_val); } @@ -418,6 +419,7 @@ print_uexpr (dstring_t *dstr, expr_t *e, int level, int id, expr_t *next) { int indent = level * 2 + 2; + _print_expr (dstr, e->e.expr.e1, level, id, next); dasprintf (dstr, "%*se_%p -> \"e_%p\";\n", indent, "", e, e->e.expr.e1); dasprintf (dstr, "%*se_%p [label=\"%s\\n%d\"];\n", indent, "", e, get_op_string (e->e.expr.op), e->line); From 8d435040e66880cdb56824a7c9ef7c56164ce288 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 25 Jan 2022 12:46:14 +0900 Subject: [PATCH 220/360] [qfcc] Clean up some type checkes Using the functions keeps the code a little easier to read. --- tools/qfcc/source/expr.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 52b0fbe84..73f23c172 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1483,7 +1483,7 @@ field_expr (expr_t *e1, expr_t *e2) t1 = get_type (e1); if (e1->type == ex_error) return e1; - if (t1->type == ev_entity) { + if (is_entity (t1)) { symbol_t *field = 0; if (e2->type == ex_symbol) @@ -1503,7 +1503,7 @@ field_expr (expr_t *e1, expr_t *e2) return e; } } - } else if (t1->type == ev_ptr) { + } else if (is_ptr (t1)) { if (is_struct (t1->t.fldptr.type)) { symbol_t *field; @@ -1529,8 +1529,7 @@ field_expr (expr_t *e1, expr_t *e2) e = new_address_expr (ivar->type, e1, e2); return unary_expr ('.', e); } - } else if (t1->type == ev_vector || t1->type == ev_quaternion - || is_struct (t1)) { + } else if (is_vector (t1) || is_quaternion (t1) || is_struct (t1)) { symbol_t *field; field = get_struct_field (t1, e1, e2); From 40f5b8a482cc67bd1f47535b5b49f20afffcc2dc Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 25 Jan 2022 12:47:12 +0900 Subject: [PATCH 221/360] [qfcc] Allow short constants in expr_int No point in generating an internal error when the value can be converted to an int. --- tools/qfcc/source/expr.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 73f23c172..de12be36d 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1160,6 +1160,9 @@ expr_int (expr_t *e) if (e->type == ex_value && e->e.value->lltype == ev_int) { return e->e.value->v.int_val; } + if (e->type == ex_value && e->e.value->lltype == ev_short) { + return e->e.value->v.short_val; + } if (e->type == ex_symbol && e->e.symbol->sy_type == sy_const && (e->e.symbol->type->type == ev_int || is_enum (e->e.symbol->type))) { From e4bb5c804852749af8a18b5177cbeb7af86a93dd Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 25 Jan 2022 22:14:12 +0900 Subject: [PATCH 222/360] [qfcc] Add pragma to control warning promotion This allows me to disable -Werror in the Makefile but still have the build tests work properly and not fail when they shouldn't. --- tools/qfcc/source/pragma.c | 20 ++++++++++++++++++++ tools/qfcc/test/classarray.r | 2 ++ tools/qfcc/test/dealloc-warn.r | 2 ++ tools/qfcc/test/dealloc-warn2.r | 2 ++ tools/qfcc/test/dealloc-warn3.r | 2 ++ tools/qfcc/test/double-demote-float-ainit.r | 2 ++ tools/qfcc/test/double-demote-float-ginit.r | 2 ++ tools/qfcc/test/double-demote-float-linit.r | 2 ++ tools/qfcc/test/double-demote-float.r | 2 ++ tools/qfcc/test/double-demote-int-ainit.r | 2 ++ tools/qfcc/test/double-demote-int-ginit.r | 2 ++ tools/qfcc/test/double-demote-int-linit.r | 2 ++ tools/qfcc/test/double-demote-int.r | 2 ++ tools/qfcc/test/double-float-compare.r | 2 ++ tools/qfcc/test/double-int-compare.r | 2 ++ 15 files changed, 48 insertions(+) diff --git a/tools/qfcc/source/pragma.c b/tools/qfcc/source/pragma.c index 616198ab2..9e3a393aa 100644 --- a/tools/qfcc/source/pragma.c +++ b/tools/qfcc/source/pragma.c @@ -107,6 +107,24 @@ set_bug (pragma_arg_t *args) } } +static void +set_warn (pragma_arg_t *args) +{ + if (!args) { + warning (0, "missing warn flag"); + return; + } + const char *flag = args->arg; + if (!strcmp (flag, "error")) { + options.warnings.promote = true; + } else if (!strcmp (flag, "!error")) { + options.warnings.promote = false; + } + if (args->next) { + warning (0, "pragma warn: ignoring extra arguments"); + } +} + void pragma_process () { @@ -123,6 +141,8 @@ pragma_process () set_traditional (0); } else if (!strcmp (id, "bug")) { set_bug (pragma_args->next); + } else if (!strcmp (id, "warn")) { + set_warn (pragma_args->next); } else { warning (0, "unknown pragma: '%s'", id); } diff --git a/tools/qfcc/test/classarray.r b/tools/qfcc/test/classarray.r index fa33d8264..972c1c3d7 100644 --- a/tools/qfcc/test/classarray.r +++ b/tools/qfcc/test/classarray.r @@ -1,3 +1,5 @@ +#pragma warn error + @interface foo { id isa; diff --git a/tools/qfcc/test/dealloc-warn.r b/tools/qfcc/test/dealloc-warn.r index bf218ca9c..86dd53a75 100644 --- a/tools/qfcc/test/dealloc-warn.r +++ b/tools/qfcc/test/dealloc-warn.r @@ -1,3 +1,5 @@ +#pragma warn error + @interface Object { Class isa; diff --git a/tools/qfcc/test/dealloc-warn2.r b/tools/qfcc/test/dealloc-warn2.r index 0cd10d3ef..921db1566 100644 --- a/tools/qfcc/test/dealloc-warn2.r +++ b/tools/qfcc/test/dealloc-warn2.r @@ -1,3 +1,5 @@ +#pragma warn error + @interface Object { Class isa; diff --git a/tools/qfcc/test/dealloc-warn3.r b/tools/qfcc/test/dealloc-warn3.r index 3d505c987..32427e2ff 100644 --- a/tools/qfcc/test/dealloc-warn3.r +++ b/tools/qfcc/test/dealloc-warn3.r @@ -1,3 +1,5 @@ +#pragma warn error + @interface Object { Class isa; diff --git a/tools/qfcc/test/double-demote-float-ainit.r b/tools/qfcc/test/double-demote-float-ainit.r index 6d380447d..7ebbb1467 100644 --- a/tools/qfcc/test/double-demote-float-ainit.r +++ b/tools/qfcc/test/double-demote-float-ainit.r @@ -1,3 +1,5 @@ +#pragma warn error + double a; int b[] = {1.0d}; int main () diff --git a/tools/qfcc/test/double-demote-float-ginit.r b/tools/qfcc/test/double-demote-float-ginit.r index c88b5e987..a23f98939 100644 --- a/tools/qfcc/test/double-demote-float-ginit.r +++ b/tools/qfcc/test/double-demote-float-ginit.r @@ -1,3 +1,5 @@ +#pragma warn error + double a; float b = 1.0d; int main () diff --git a/tools/qfcc/test/double-demote-float-linit.r b/tools/qfcc/test/double-demote-float-linit.r index 796b2040f..2eba60432 100644 --- a/tools/qfcc/test/double-demote-float-linit.r +++ b/tools/qfcc/test/double-demote-float-linit.r @@ -1,3 +1,5 @@ +#pragma warn error + double a; int main () { diff --git a/tools/qfcc/test/double-demote-float.r b/tools/qfcc/test/double-demote-float.r index 330a0bdef..f38db3a96 100644 --- a/tools/qfcc/test/double-demote-float.r +++ b/tools/qfcc/test/double-demote-float.r @@ -1,3 +1,5 @@ +#pragma warn error + double a; float b; int main () diff --git a/tools/qfcc/test/double-demote-int-ainit.r b/tools/qfcc/test/double-demote-int-ainit.r index 6d380447d..7ebbb1467 100644 --- a/tools/qfcc/test/double-demote-int-ainit.r +++ b/tools/qfcc/test/double-demote-int-ainit.r @@ -1,3 +1,5 @@ +#pragma warn error + double a; int b[] = {1.0d}; int main () diff --git a/tools/qfcc/test/double-demote-int-ginit.r b/tools/qfcc/test/double-demote-int-ginit.r index 767328715..80fa7857a 100644 --- a/tools/qfcc/test/double-demote-int-ginit.r +++ b/tools/qfcc/test/double-demote-int-ginit.r @@ -1,3 +1,5 @@ +#pragma warn error + double a; int b = 1.0d; int main () diff --git a/tools/qfcc/test/double-demote-int-linit.r b/tools/qfcc/test/double-demote-int-linit.r index 3a206f4b5..523cca503 100644 --- a/tools/qfcc/test/double-demote-int-linit.r +++ b/tools/qfcc/test/double-demote-int-linit.r @@ -1,3 +1,5 @@ +#pragma warn error + double a; int main () { diff --git a/tools/qfcc/test/double-demote-int.r b/tools/qfcc/test/double-demote-int.r index bebef5436..dd921215f 100644 --- a/tools/qfcc/test/double-demote-int.r +++ b/tools/qfcc/test/double-demote-int.r @@ -1,3 +1,5 @@ +#pragma warn error + double a; int b; int main () diff --git a/tools/qfcc/test/double-float-compare.r b/tools/qfcc/test/double-float-compare.r index a219b0d4a..37a4bfb03 100644 --- a/tools/qfcc/test/double-float-compare.r +++ b/tools/qfcc/test/double-float-compare.r @@ -1,3 +1,5 @@ +#pragma warn error + double a; float b; int main () diff --git a/tools/qfcc/test/double-int-compare.r b/tools/qfcc/test/double-int-compare.r index 221516ed8..374b32edc 100644 --- a/tools/qfcc/test/double-int-compare.r +++ b/tools/qfcc/test/double-int-compare.r @@ -1,3 +1,5 @@ +#pragma warn error + double a; int b; int main () From 06d70a32db2c51dd672b2d6bed2112c50d520316 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 25 Jan 2022 23:39:17 +0900 Subject: [PATCH 223/360] [qfcc] Rework the functionality of address expressions The goal was to get lea being used for locals in ruamoko progs because lea takes the base registers into account while the constant pointer defs used by v6p cannot. Pointer defs are still used for gobals as they may be out of reach of 16-bit addressing. address_expr() has been simplified in that it no longer takes an offset: the vast majority of the callers never passed one, and the few that did have been reworked to use other mechanisms. In particular, offset_pointer_expr does the manipulations needed to add an offset (unscaled by type size) to a pointer. High-level pointer offsets still apply a scale, though. Alias expressions now do a better job of hanling aliasing of aliases by simply replacing the target type when possible. --- tools/qfcc/include/expr.h | 3 +- tools/qfcc/source/class.c | 2 +- tools/qfcc/source/expr.c | 117 ++++++++++++++++++-------------- tools/qfcc/source/expr_assign.c | 2 +- tools/qfcc/source/expr_binary.c | 10 +-- tools/qfcc/source/expr_obj.c | 2 +- tools/qfcc/source/flow.c | 8 ++- tools/qfcc/source/qc-parse.y | 2 +- tools/qfcc/source/statements.c | 81 ++++++++++++++-------- tools/qfcc/source/switch.c | 2 +- 10 files changed, 136 insertions(+), 93 deletions(-) diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 977a018ff..641b04246 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -767,7 +767,8 @@ expr_t *conditional_expr (expr_t *cond, expr_t *e1, expr_t *e2); expr_t *incop_expr (int op, expr_t *e, int postop); expr_t *array_expr (expr_t *array, expr_t *index); expr_t *deref_pointer_expr (expr_t *pointer); -expr_t *address_expr (expr_t *e1, expr_t *e2, struct type_s *t); +expr_t *offset_pointer_expr (expr_t *pointer, expr_t *offset); +expr_t *address_expr (expr_t *e1, struct type_s *t); expr_t *build_if_statement (int not, expr_t *test, expr_t *s1, expr_t *els, expr_t *s2); expr_t *build_while_statement (int not, expr_t *test, expr_t *statement, diff --git a/tools/qfcc/source/class.c b/tools/qfcc/source/class.c index 3f141ede9..ce4499fdc 100644 --- a/tools/qfcc/source/class.c +++ b/tools/qfcc/source/class.c @@ -1555,7 +1555,7 @@ class_finish_module (void) init_sym = new_symbol_type (".ctor", &type_func); init_sym = function_symbol (init_sym, 0, 1); - module_expr = address_expr (new_symbol_expr (module_sym), 0, 0); + module_expr = address_expr (new_symbol_expr (module_sym), 0); init_expr = new_block_expr (); append_expr (init_expr, diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index de12be36d..497de95c6 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1304,7 +1304,10 @@ expr_t * new_alias_expr (type_t *type, expr_t *expr) { if (expr->type == ex_alias) { - return new_offset_alias_expr (type, expr, 0); + if (expr->e.alias.offset) { + return new_offset_alias_expr (type, expr, 0); + } + expr = expr->e.alias.expr; } expr_t *alias = new_expr (); @@ -1527,10 +1530,10 @@ field_expr (expr_t *e1, expr_t *e2) ivar = class_find_ivar (class, protected, sym->name); if (!ivar) return new_error_expr (); - e2->type = ex_value; - e2->e.value = new_short_val (ivar->s.offset); - e = new_address_expr (ivar->type, e1, e2); - return unary_expr ('.', e); + expr_t *offset = new_short_expr (ivar->s.offset); + e1 = offset_pointer_expr (e1, offset); + e1 = cast_expr (pointer_type (ivar->type), e1); + return unary_expr ('.', e1); } } else if (is_vector (t1) || is_quaternion (t1) || is_struct (t1)) { symbol_t *field; @@ -1564,10 +1567,10 @@ field_expr (expr_t *e1, expr_t *e2) return field_expr (e1, e2); } else { if (e1->type == ex_uexpr && e1->e.expr.op == '.') { - e2->type = ex_value; - e2->e.value = new_short_val (field->s.offset); - e = address_expr (e1, e2, field->type); - return unary_expr ('.', e); + expr_t *offset = new_short_expr (field->s.offset); + e1 = offset_pointer_expr (e1->e.expr.e1, offset); + e1 = cast_expr (pointer_type (field->type), e1); + return unary_expr ('.', e1); } else { return new_offset_alias_expr (field->type, e1, field->s.offset); } @@ -2470,7 +2473,7 @@ incop_expr (int op, expr_t *e, int postop) append_expr (block, assign_expr (t2, binary_expr (op, t1, one))); res = copy_expr (e); if (res->type == ex_uexpr && res->e.expr.op == '.') - res = deref_pointer_expr (address_expr (res, 0, 0)); + res = deref_pointer_expr (address_expr (res, 0)); append_expr (block, assign_expr (res, t2)); block->e.block.result = t1; return block; @@ -2487,6 +2490,7 @@ array_expr (expr_t *array, expr_t *index) expr_t *scale; expr_t *offset; expr_t *base; + expr_t *ptr; expr_t *e; int ind = 0; @@ -2495,7 +2499,7 @@ array_expr (expr_t *array, expr_t *index) if (index->type == ex_error) return index; - if (array_type->type != ev_ptr && !is_array (array_type)) + if (!is_ptr (array_type) && !is_array (array_type)) return error (array, "not an array"); if (!is_integral (index_type)) return error (index, "invalid array index type"); @@ -2503,7 +2507,8 @@ array_expr (expr_t *array, expr_t *index) ind = expr_short (index); if (is_int_val (index)) ind = expr_int (index); - if (array_type->t.func.num_params + if (is_array (array_type) + && array_type->t.array.size && is_constant (index) && (ind < array_type->t.array.base || ind - array_type->t.array.base >= array_type->t.array.size)) @@ -2517,18 +2522,21 @@ array_expr (expr_t *array, expr_t *index) ind = expr_short (index); if (is_int_val (index)) ind = expr_int (index); - if ((is_constant (index) && ind < 32768 && ind >= -32768)) - index = new_short_expr (ind); if (is_array (array_type)) { - e = address_expr (array, index, array_type->t.array.type); - } else { - if (!is_short_val (index) || expr_short (index)) { - e = new_address_expr (array_type->t.array.type, array, index); + type_t *element_type = array_type->t.array.type; + if (array->type == ex_uexpr && array->e.expr.op == '.') { + ptr = array->e.expr.e1; } else { - e = array; + expr_t *alias = new_offset_alias_expr (element_type, array, 0); + ptr = new_address_expr (element_type, alias, 0); } + } else { + ptr = array; } - e = unary_expr ('.', e); + ptr = offset_pointer_expr (ptr, index); + ptr = cast_expr (pointer_type (array_type->t.array.type), ptr); + + e = unary_expr ('.', ptr); return e; } @@ -2545,7 +2553,28 @@ deref_pointer_expr (expr_t *pointer) } expr_t * -address_expr (expr_t *e1, expr_t *e2, type_t *t) +offset_pointer_expr (expr_t *pointer, expr_t *offset) +{ + type_t *ptr_type = get_type (pointer); + if (!is_ptr (ptr_type)) { + internal_error (pointer, "not a pointer"); + } + if (!is_integral (get_type (offset))) { + internal_error (offset, "pointer offset is not an integer type"); + } + expr_t *ptr; + if (pointer->type == ex_alias && !pointer->e.alias.offset + && is_integral (get_type (pointer->e.alias.expr))) { + ptr = pointer->e.alias.expr; + } else { + ptr = cast_expr (&type_int, pointer); + } + ptr = binary_expr ('+', ptr, offset); + return cast_expr (ptr_type, ptr); +} + +expr_t * +address_expr (expr_t *e1, type_t *t) { expr_t *e; @@ -2561,6 +2590,12 @@ address_expr (expr_t *e1, expr_t *e2, type_t *t) def_t *def = e1->e.def; type_t *type = def->type; + //FIXME this test should be in statements.c + if (options.code.progsversion == PROG_VERSION + && (def->local || def->param)) { + e = new_address_expr (t, e1, 0); + return e; + } if (is_array (type)) { e = e1; e->type = ex_value; @@ -2577,6 +2612,13 @@ address_expr (expr_t *e1, expr_t *e2, type_t *t) def_t *def = e1->e.symbol->s.def; type_t *type = def->type; + //FIXME this test should be in statements.c + if (options.code.progsversion == PROG_VERSION + && (def->local || def->param)) { + e = new_address_expr (t, e1, 0); + return e; + } + if (is_array (type)) { e = e1; e->type = ex_value; @@ -2614,39 +2656,10 @@ address_expr (expr_t *e1, expr_t *e2, type_t *t) if (!t) { t = e1->e.alias.type; } - if (e1->e.alias.offset) { - if (e2) { - e2 = binary_expr ('+', e1->e.alias.offset, e2); - } else { - e2 = e1->e.alias.offset; - } - } - return address_expr (e1->e.alias.expr, e2, t); + return new_address_expr (t, e1, 0); default: return error (e1, "invalid type for unary &"); } - if (e2) { - if (e2->type == ex_error) - return e2; - if (is_pointer_val (e) && is_integral_val (e2)) { - int base = e->e.value->v.pointer.val; - int offset = expr_integral (e2); - def_t *def = e->e.value->v.pointer.def; - e->e.value = new_pointer_val (base + offset, t, def, 0); - } else { - expr_t *offset = 0; - if (e->type == ex_address) { - offset = e->e.address.offset; - e1 = e->e.address.lvalue; - } else { - e1 = e; - } - if (offset) { - e2 = binary_expr ('+', offset, e2); - } - e = new_address_expr (t, e1, e2); - } - } return e; } @@ -2928,7 +2941,7 @@ cast_expr (type_t *dstType, expr_t *e) return cast_error (e, srcType, dstType); } if (is_array (srcType)) { - return address_expr (e, 0, dstType->t.fldptr.type); + return address_expr (e, dstType->t.fldptr.type); } if (is_constant (e) && is_scalar (dstType) && is_scalar (srcType)) { ex_value_t *val = 0; diff --git a/tools/qfcc/source/expr_assign.c b/tools/qfcc/source/expr_assign.c index 9aa1f2784..f9a66b1be 100644 --- a/tools/qfcc/source/expr_assign.c +++ b/tools/qfcc/source/expr_assign.c @@ -335,7 +335,7 @@ assign_expr (expr_t *dst, expr_t *src) if (is_ptr (dst_type) && is_array (src_type)) { // assigning an array to a pointer is the same as taking the address of // the array but using the type of the array elements - src = address_expr (src, 0, src_type->t.fldptr.type); + src = address_expr (src, src_type->t.fldptr.type); src_type = get_type (src); } if (src->type == ex_bool) { diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index 27e7f1ff8..22d4b8a5a 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -638,7 +638,6 @@ static expr_type_t **binary_expr_types[ev_type_count] = { static expr_t * pointer_arithmetic (int op, expr_t *e1, expr_t *e2) { - expr_t *e; type_t *t1 = get_type (e1); type_t *t2 = get_type (e2); expr_t *ptr; @@ -663,16 +662,17 @@ pointer_arithmetic (int op, expr_t *e1, expr_t *e2) return binary_expr ('/', binary_expr ('-', e1, e2), psize); } else if (is_ptr (t1)) { offset = cast_expr (&type_int, e2); - ptr = cast_expr (&type_int, e1); + ptr = e1; ptype = t1; } else if (is_ptr (t2)) { offset = cast_expr (&type_int, e1); - ptr = cast_expr (&type_int, e2); + ptr = e2; ptype = t2; } + // op is known to be + or - psize = new_int_expr (type_size (ptype->t.fldptr.type)); - e = binary_expr (op, ptr, binary_expr ('*', offset, psize)); - return cast_expr (ptype, e); + offset = unary_expr (op, binary_expr ('*', offset, psize)); + return offset_pointer_expr (ptr, offset); } static expr_t * diff --git a/tools/qfcc/source/expr_obj.c b/tools/qfcc/source/expr_obj.c index 6a8bedebf..41405c1e4 100644 --- a/tools/qfcc/source/expr_obj.c +++ b/tools/qfcc/source/expr_obj.c @@ -172,7 +172,7 @@ super_expr (class_type_t *class_type) field_expr (e, new_name_expr ("super_class"))); append_expr (super_block, e); - e = address_expr (super, 0, 0); + e = address_expr (super, 0); super_block->e.block.result = e; return super_block; } diff --git a/tools/qfcc/source/flow.c b/tools/qfcc/source/flow.c index 753b15928..4b501c027 100644 --- a/tools/qfcc/source/flow.c +++ b/tools/qfcc/source/flow.c @@ -1183,7 +1183,13 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, internal_error (s->expr, "not a statement"); case st_expr: flow_add_op_var (def, s->opc, 0); - flow_add_op_var (use, s->opa, 1); + if (strcmp (s->opcode, "lea") == 0) { + if (s->opb) { + flow_add_op_var (use, s->opa, 1); + } + } else { + flow_add_op_var (use, s->opa, 1); + } if (s->opb) flow_add_op_var (use, s->opb, 1); if (operands) { diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index 399f91b1e..282f501ae 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -1559,7 +1559,7 @@ unary_expr | '-' cast_expr %prec UNARY { $$ = unary_expr ('-', $2); } | '!' cast_expr %prec UNARY { $$ = unary_expr ('!', $2); } | '~' cast_expr %prec UNARY { $$ = unary_expr ('~', $2); } - | '&' cast_expr %prec UNARY { $$ = address_expr ($2, 0, 0); } + | '&' cast_expr %prec UNARY { $$ = address_expr ($2, 0); } | '*' cast_expr %prec UNARY { $$ = deref_pointer_expr ($2); } | SIZEOF unary_expr %prec UNARY { $$ = sizeof_expr ($2, 0); } | SIZEOF '(' abstract_decl ')' %prec HYPERUNARY diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 028ec9e96..3ff6df7bd 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -727,10 +727,20 @@ static sblock_t * expr_address (sblock_t *sblock, expr_t *e, operand_t **op) { statement_t *s; + expr_t *lvalue = e->e.address.lvalue; + expr_t *offset = e->e.address.offset; + + if (lvalue->type == ex_alias && offset && is_constant (offset)) { + lvalue = new_offset_alias_expr (lvalue->e.alias.type, + lvalue->e.alias.expr, + expr_int (offset)); + offset = 0; + } + s = new_statement (st_expr, "lea", e); - sblock = statement_subexpr (sblock, e->e.address.lvalue, &s->opa); - if (e->e.address.offset) { - sblock = statement_subexpr (sblock, e->e.address.offset, &s->opb); + sblock = statement_subexpr (sblock, lvalue, &s->opa); + if (offset) { + sblock = statement_subexpr (sblock, offset, &s->opb); } s->opc = temp_operand (e->e.address.type, e); sblock_add_statement (sblock, s); @@ -836,7 +846,7 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) } } else { if (is_indirect (src_expr)) { - src_expr = expr_file_line (address_expr (src_expr, 0, 0), e); + src_expr = expr_file_line (address_expr (src_expr, 0), e); need_ptr = 1; } if (!src) { @@ -860,7 +870,7 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) // dst_expr and/or src_expr are dereferenced pointers, so need to // un-dereference dst_expr to get the pointer and switch to movep // or memsetp instructions. - dst_expr = expr_file_line (address_expr (dst_expr, 0, 0), e); + dst_expr = expr_file_line (address_expr (dst_expr, 0), e); need_ptr = 1; } sblock = statement_subexpr (sblock, dst_expr, &dst); @@ -945,7 +955,7 @@ expr_assign (sblock_t *sblock, expr_t *e, operand_t **op) dereference_dst: // dst_expr is a dereferenced pointer, so need to un-dereference it // to get the pointer and switch to storep instructions. - dst_expr = expr_file_line (address_expr (dst_expr, 0, 0), e); + dst_expr = expr_file_line (address_expr (dst_expr, 0), e); opcode = "store"; if (dst_expr->type == ex_address && dst_expr->e.address.offset && !is_const_ptr (dst_expr->e.address.lvalue)) { @@ -1167,7 +1177,7 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) sblock = statement_slist (sblock, assign); if (args_params) { - list = address_expr (args_params, 0, &type_param); + list = address_expr (args_params, &type_param); } else { list = new_nil_expr (); } @@ -1258,8 +1268,10 @@ statement_return (sblock_t *sblock, expr_t *e) s = new_statement (st_func, opcode, e); if (options.code.progsversion < PROG_VERSION) { if (e->e.retrn.ret_val) { - s->opa = return_operand (get_type (e->e.retrn.ret_val), e); - sblock = statement_subexpr (sblock, e->e.retrn.ret_val, &s->opa); + expr_t *ret_val = e->e.retrn.ret_val; + type_t *ret_type = get_type (ret_val); + s->opa = return_operand (ret_type, e); + sblock = statement_subexpr (sblock, ret_val, &s->opa); } } else { if (e->e.retrn.ret_val) { @@ -1316,6 +1328,28 @@ lea_statement (operand_t *pointer, operand_t *offset, expr_t *e) return s; } +static statement_t * +movep_statement (operand_t *dst, operand_t *src, type_t *type, expr_t *e) +{ + operand_t *dst_addr = operand_address (dst, e); + statement_t *s = new_statement (st_ptrmove, "movep", e); + s->opa = src; + //FIXME large types + s->opb = short_operand (type_size (type), e); + s->opc = dst_addr; + return s; +} + +static statement_t * +load_statement (operand_t *ptr, operand_t *offs, operand_t *op, expr_t *e) +{ + statement_t *s = new_statement (st_expr, "load", e); + s->opa = ptr; + s->opb = offs; + s->opc = op; + return s; +} + static sblock_t * expr_deref (sblock_t *sblock, expr_t *deref, operand_t **op) { @@ -1337,26 +1371,13 @@ expr_deref (sblock_t *sblock, expr_t *deref, operand_t **op) if (!*op) *op = temp_operand (type, e); if (low_level_type (type) == ev_void) { - operand_t *src_addr; - operand_t *dst_addr; - s = lea_statement (ptr, offs, e); - src_addr = s->opc; sblock_add_statement (sblock, s); - dst_addr = operand_address (*op, e); - - s = new_statement (st_ptrmove, "movep", deref); - s->opa = src_addr; - //FIXME large types - s->opb = short_operand (type_size (type), e); - s->opc = dst_addr; + s = movep_statement (*op, s->opc, type, deref); sblock_add_statement (sblock, s); } else { - s = new_statement (st_expr, "load", deref); - s->opa = ptr; - s->opb = offs; - s->opc = *op; + s = load_statement (ptr, offs, *op, deref); sblock_add_statement (sblock, s); } } else if (e->type == ex_value && e->e.value->lltype == ev_ptr) { @@ -1370,11 +1391,13 @@ expr_deref (sblock_t *sblock, expr_t *deref, operand_t **op) sblock = statement_subexpr (sblock, e, &ptr); if (!*op) *op = temp_operand (type, e); - s = new_statement (st_expr, "load", deref); - s->opa = ptr; - s->opb = short_operand (0, e); - s->opc = *op; - sblock_add_statement (sblock, s); + if (low_level_type (type) == ev_void) { + s = movep_statement (*op, ptr, type, deref); + sblock_add_statement (sblock, s); + } else { + s = load_statement (ptr, short_operand (0, e), *op, deref); + sblock_add_statement (sblock, s); + } } return sblock; } diff --git a/tools/qfcc/source/switch.c b/tools/qfcc/source/switch.c index 10b8dc342..f275af673 100644 --- a/tools/qfcc/source/switch.c +++ b/tools/qfcc/source/switch.c @@ -343,7 +343,7 @@ build_switch (expr_t *sw, case_node_t *tree, int op, expr_t *sw_val, table_init = new_compound_init (); for (i = 0; i <= high - low; i++) { tree->labels[i]->e.label.used++; - label = address_expr (tree->labels[i], 0, 0); + label = address_expr (tree->labels[i], 0); append_element (table_init, new_element (label, 0)); } table_sym = new_symbol_type (table_name, From 6bc6db471dd3457e4206c2d384baa4873585626c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 26 Jan 2022 09:51:11 +0900 Subject: [PATCH 224/360] [gamecode] Make return use same addressing as other ops This makes return consistent with load, store, etc, though its addressing mode is encoded in bits 5 and 6 of c rather than the opcode. It turns out I had no tests for any of return's addressing modes other than basic def references, so no tests needed changing. --- libs/gamecode/pr_exec.c | 35 +---------------------------------- 1 file changed, 1 insertion(+), 34 deletions(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 80df7c310..b0a81c376 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1820,39 +1820,6 @@ pr_address_mode (progs_t *pr, const dstatement_t *st, int mm_ind) return pr->pr_globals + mm_offs; } -static pr_type_t * -pr_return_mode (progs_t *pr, const dstatement_t *st, int mm_ind) -{ - pr_type_t *op_a = pr->pr_globals + st->a + PR_BASE (pr, st, A); - pr_type_t *op_b = pr->pr_globals + st->b + PR_BASE (pr, st, B); - pr_ptr_t mm_offs = 0; - - switch (mm_ind) { - case 0: - // regular global access - mm_offs = op_a - pr->pr_globals; - break; - case 1: - // simple pointer dereference: *a - mm_offs = OPA(ptr); - break; - case 2: - // constant indexed pointer: *a + b (supports -ve offset) - mm_offs = OPA(ptr) + (short) st->b; - break; - case 3: - // variable indexed pointer: *a + *b (supports -ve offset) - mm_offs = OPA(ptr) + OPB(int); - break; - case 4: - // entity.field (equivalent to OP_LOAD_t_v6p) - pr_ptr_t edict_area = pr->pr_edict_area - pr->pr_globals; - mm_offs = edict_area + OPA(entity) + OPB(field); - break; - } - return pr->pr_globals + mm_offs; -} - static pr_type_t * pr_call_mode (progs_t *pr, const dstatement_t *st, int mm_ind) { @@ -3184,7 +3151,7 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_RETURN: int ret_size = (st->c & 0x1f) + 1; // up to 32 words if (st->c != 0xffff) { - mm = pr_return_mode (pr, st, st->c >> 5); + mm = pr_address_mode (pr, st, st->c >> 5); memcpy (&R_INT (pr), mm, ret_size * sizeof (*op_a)); } pr->pr_xfunction->profile += profile - startprofile; From ee4eecc7414f82fe55f5ae5743487fdca895111e Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 26 Jan 2022 12:26:12 +0900 Subject: [PATCH 225/360] [gamecode] Correct types and opname for memset and move --- libs/gamecode/opcodes.py | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index d6cb80f6f..d8b9ed711 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -254,10 +254,10 @@ mathops_formats = { memset_formats = { "opcode": "OP_MEMSET_{op_memset[oo].upper()}", "mnemonic": "memset.{op_memset[oo]}", - "opname": "memset", + "opname": "memset{op_memset[oo]}", "format": "{memset_fmt[oo]}", "widths": "{memset_widths[oo]}", - "types": "ev_int, ev_void, ev_void", + "types": "{memset_types[oo]}", "args": { "op_memset": ["i", "p", "pi", None], "memset_fmt": ["%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc", None], @@ -267,17 +267,23 @@ memset_formats = { "1, 0, 1", None, ], + "memset_types": [ + "ev_void, ev_short, ev_void", + "ev_ptr, ev_int, ev_ptr", + "ev_ptr, ev_short, ev_ptr", + ], }, } move_formats = { "opcode": "OP_MOVE_{op_move[oo].upper()}", - "mnemonic": "memset.{op_move[oo]}", - "opname": "memset", + "mnemonic": "move.{op_move[oo]}", + "opname": "move{suff_move[oo]}", "format": "{move_fmt[oo]}", "widths": "{move_widths[oo]}", - "types": "ev_int, ev_void, ev_void", + "types": "{move_types[oo]}", "args": { "op_move": ["i", "p", "pi", None], + "suff_move": ["", "p", "p", None], "move_fmt": ["%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc", None], "move_widths": [ "-1, 0, -1", @@ -285,6 +291,11 @@ move_formats = { "1, 0, 1", None, ], + "move_types": [ + "ev_void, ev_short, ev_void", + "ev_ptr, ev_int, ev_ptr", + "ev_ptr, ev_short, ev_ptr", + ], }, } noop_formats = { From 982a090143779076e44b24373e1dc94eaac8d77f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 26 Jan 2022 12:26:50 +0900 Subject: [PATCH 226/360] [qfcc] Mask off base register bits when printing statements Fixes a segfault when compiling Ruamoko progs with debug output. --- tools/qfcc/source/opcodes.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index 7687851d9..51c7ce26d 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -403,11 +403,14 @@ void opcode_print_statement (pr_uint_t addr, dstatement_t *st) { const char *mnemonic; + // this is ok because v6p has < 300 instructions + int st_op = st->op & 0x1ff; + if (options.code.progsversion < PROG_VERSION) { - mnemonic = v6p_opcode_map[st->op].opname; + mnemonic = v6p_opcode_map[st_op].opname; } else { - mnemonic = pr_opcodes[st->op].mnemonic; + mnemonic = pr_opcodes[st_op].mnemonic; } printf ("%04x (%03x)%-8s %04x %04x %04x\n", - addr, st->op & 0x1ff, mnemonic, st->a, st->b, st->c); + addr, st_op & 0x1ff, mnemonic, st->a, st->b, st->c); } From 0b9b6955aa656327b8cf3137deeeb3f4f6c66950 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 26 Jan 2022 12:28:05 +0900 Subject: [PATCH 227/360] [qfcc] Implement addressing modes for return There's still entity.field to go, but basic def and ptr + const offset seem to work. --- tools/qfcc/source/statements.c | 77 ++++++++++++++++++++++++++++++---- 1 file changed, 70 insertions(+), 7 deletions(-) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 3ff6df7bd..e0ef25160 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1252,6 +1252,70 @@ statement_branch (sblock_t *sblock, expr_t *e) return sblock->next; } +static sblock_t * +addressing_mode (sblock_t *sblock, expr_t *ref, + operand_t **base, operand_t **offset, pr_ushort_t *mode) +{ + if (is_indirect (ref)) { + // ref is known to be either ex_expr or ex_uexpr, with '.' for + // the operator + if (ref->type == ex_expr) { + internal_error (ref, "not implemented"); + } else if (ref->type == ex_uexpr) { + ref = ref->e.expr.e1; + if (!is_ptr (get_type (ref))) { + internal_error (ref, "expected pointer in ref"); + } + if (ref->type != ex_alias || ref->e.alias.offset) { + // probably just a pointer + sblock = statement_subexpr (sblock, ref, base); + *offset = short_operand (0, ref); + *mode = 2; // mode C: ptr + constant index + } else { + // alias with no offset + if (!is_integral (get_type (ref->e.alias.expr))) { + internal_error (ref, "expected integer expr in ref"); + } + expr_t *intptr = ref->e.alias.expr; + if (intptr->type != ex_expr + || (intptr->e.expr.op != '+' + && intptr->e.expr.op != '-')) { + // treat ref as simple pointer + sblock = statement_subexpr (sblock, ref, base); + *offset = short_operand (0, ref); + *mode = 2; // mode C: ptr + constant index + } else { + expr_t *ptr = intptr->e.expr.e1; + expr_t *offs = intptr->e.expr.e2; + int const_offs; + // move the +/- to the offset + offs = unary_expr (intptr->e.expr.op, offs); + // make the base a pointer again + ptr = new_alias_expr (ref->e.alias.type, ptr); + sblock = statement_subexpr (sblock, ptr, base); + if (is_constant (offs) + && (const_offs = expr_int (offs)) < 32768 + && const_offs >= -32768) { + *mode = 2; + *offset = short_operand (const_offs, ref); + } else { + *mode = 3; + sblock = statement_subexpr (sblock, offs, offset); + } + } + } + } else { + internal_error (ref, "unexpected expression type for indirect: %s", + expr_names[ref->type]); + } + } else { + sblock = statement_subexpr (sblock, ref, base); + *offset = short_operand (0, ref); + *mode = 0; + } + return sblock; +} + static sblock_t * statement_return (sblock_t *sblock, expr_t *e) { @@ -1277,16 +1341,15 @@ statement_return (sblock_t *sblock, expr_t *e) if (e->e.retrn.ret_val) { expr_t *ret_val = e->e.retrn.ret_val; type_t *ret_type = get_type (ret_val); - if (is_indirect (ret_val)) { - } else { - sblock = statement_subexpr (sblock, ret_val, &s->opa); - s->opb = short_operand (0, e); - s->opc = short_operand (type_size (ret_type) - 1, e); - } + pr_ushort_t ret_crtl = type_size (ret_type) - 1; + pr_ushort_t mode = 0; + sblock = addressing_mode (sblock, ret_val, &s->opa, &s->opb, &mode); + ret_crtl |= mode << 5; + s->opc = short_operand (ret_crtl, e); } else { s->opa = short_operand (0, e); s->opb = short_operand (0, e); - s->opc = short_operand (-1, e); + s->opc = short_operand (-1, e); // void return } } sblock_add_statement (sblock, s); From 90b40e7e52d6d8c81e3bd2a85ed9acf46cd62b97 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 26 Jan 2022 12:56:15 +0900 Subject: [PATCH 228/360] [qfcc] Ensure adjstk and with always come first While I think the reason the dags code moved an instruction before adjstk and with was they shared a constant with that instruction (which is a different bug), this ensures other instructions cannot get reordered in front of adjstk and with, as doing so would cause any such instructions to access incorrect data. --- tools/qfcc/source/function.c | 25 ++++++++++++++++++++----- 1 file changed, 20 insertions(+), 5 deletions(-) diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index 81a20af46..d094fc152 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -729,17 +729,32 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements) } function_t *func = fsym->s.func; if (options.code.progsversion == PROG_VERSION) { + /* Create a function entry block to set up the stack frame and add the + * actual function code to that block. This ensure that the adjstk and + * with statements always come first, regardless of what ideas the + * optimizer gets. + */ expr_t *e; - e = new_with_expr (2, LOCALS_REG, new_short_expr (0)); - e->file = func->def->file; - e->line = func->def->line; - prepend_expr (statements, e); + expr_t *entry = new_block_expr (); + entry->file = func->def->file; + entry->line = func->def->line; e = new_adjstk_expr (0, 0); e->file = func->def->file; e->line = func->def->line; - prepend_expr (statements, e); + append_expr (entry, e); + e = new_with_expr (2, LOCALS_REG, new_short_expr (0)); + e->file = func->def->file; + e->line = func->def->line; + append_expr (entry, e); + + append_expr (entry, statements); + statements = entry; + + /* Mark all local defs as using the base register used for stack + * references. + */ func->temp_reg = LOCALS_REG; for (def_t *def = func->locals->space->defs; def; def = def->next) { if (def->local || def->param) { From a2f4522e76442a3711d54e5fd5babdb7c9b0052a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 26 Jan 2022 16:55:14 +0900 Subject: [PATCH 229/360] [gamecode] Align Ruamoko progs to 32 bytes. Intel hardware requires 32-byte alignment for lvec4 and dvec4. Unfortunately, it turns out that my attempts to align progs data in qfcc went awry do to the order block sizes are calculated when writing the progs. --- libs/gamecode/pr_load.c | 30 ++++++++++++++++-------------- 1 file changed, 16 insertions(+), 14 deletions(-) diff --git a/libs/gamecode/pr_load.c b/libs/gamecode/pr_load.c index e8538d5bd..6d7116856 100644 --- a/libs/gamecode/pr_load.c +++ b/libs/gamecode/pr_load.c @@ -95,13 +95,10 @@ free_progs_mem (progs_t *pr, void *mem) } static int -align_size (int size) +align_size (int size, int align) { - // round off to next highest whole word address (esp for Alpha) - // this ensures that pointers in the engine data area are always - // properly aligned - size += sizeof (void*) - 1; - size &= ~(sizeof (void*) - 1); + size += align - 1; + size &= ~(align - 1); return size; } @@ -117,6 +114,8 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) pr_def_t *xdefs_def = 0; ddef_t *global_ddefs; ddef_t *field_ddefs; + // absolute minimum alignment is 4 bytes + int alignment = sizeof (void *); if (!pr->file_error) pr->file_error = file_error; @@ -163,6 +162,12 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) PROG_VERSION & 0xfff); } } + if (progs.version == PROG_VERSION) { + // ensure SIMD types can be aligned (qfcc will align them within + // the progs memory map, so the engine needs to ensure the progs memory + // is aligned) + alignment = __alignof__(pr_lvec4_t); + } // Some compilers (eg, FTE) put extra data between the header and the // strings section. What's worse, they de-align the data. @@ -173,17 +178,14 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) pr->progs_size = size + offset_tweak; Sys_MaskPrintf (SYS_dev, "Programs occupy %iK.\n", size / 1024); - pr->progs_size = align_size (pr->progs_size); - pr->zone_size = align_size (pr->zone_size); - pr->stack_size = align_size (pr->stack_size); + pr->progs_size = align_size (pr->progs_size, alignment); + pr->zone_size = align_size (pr->zone_size, alignment); + pr->stack_size = align_size (pr->stack_size, alignment); // size of edict asked for by progs, but at least 1 pr->pr_edict_size = max (1, progs.entityfields); - // round off to next highest multiple of 4 words - // this ensures that progs that try to align vectors and quaternions - // get what they want - pr->pr_edict_size += (4 - 1); - pr->pr_edict_size &= ~(4 - 1); + // edict size is in words + pr->pr_edict_size = align_size (pr->pr_edict_size, alignment / 4); pr->pr_edict_area_size = pr->max_edicts * pr->pr_edict_size; mem_size = pr->pr_edict_area_size * sizeof (pr_type_t); From a2fd42f174e8ec61f3d40c930f813d6042dac2ce Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 26 Jan 2022 16:57:34 +0900 Subject: [PATCH 230/360] [qfcc] Align progs memory to 32 bytes in the test harness This ensures the engine can align everything to 32 bytes. --- tools/qfcc/test/test-harness.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/test/test-harness.c b/tools/qfcc/test/test-harness.c index bf51508b9..a0a4bfd0c 100644 --- a/tools/qfcc/test/test-harness.c +++ b/tools/qfcc/test/test-harness.c @@ -120,10 +120,14 @@ load_file (progs_t *pr, const char *name, off_t *_size) return sym; } +#define ALIGN 32 + static void * allocate_progs_mem (progs_t *pr, int size) { - return malloc (size); + intptr_t mem = (intptr_t) malloc (size + ALIGN); + mem = (mem + ALIGN - 1) & ~(ALIGN - 1); + return (void *) mem; } static void From faa98d81985773fa86f4508e6b8875b5c45990da Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 26 Jan 2022 19:30:25 +0900 Subject: [PATCH 231/360] [gamecode] Use a struct for offset/count pairs This cleans up dprograms_t, making it easier to read and see what chunks are in it (I was surprised to see only 6, the explicit pairs made it seem to have more). --- include/QF/progs/pr_comp.h | 30 +++++------ libs/gamecode/pr_builtins.c | 4 +- libs/gamecode/pr_debug.c | 24 ++++----- libs/gamecode/pr_exec.c | 6 +-- libs/gamecode/pr_load.c | 38 ++++++------- libs/gamecode/pr_parse.c | 4 +- libs/gamecode/pr_resolve.c | 4 +- libs/gamecode/pr_strings.c | 2 +- libs/gamecode/pr_v6p_opcode.c | 12 ++--- libs/gamecode/test/main.c | 2 +- ruamoko/qwaq/builtins/debug.c | 8 +-- tools/qfcc/source/disassemble.c | 2 +- tools/qfcc/source/dump_globals.c | 18 +++---- tools/qfcc/source/dump_lines.c | 2 +- tools/qfcc/source/dump_modules.c | 2 +- tools/qfcc/source/dump_strings.c | 2 +- tools/qfcc/source/idstuff.c | 12 ++--- tools/qfcc/source/obj_file.c | 92 ++++++++++++++++---------------- tools/qfcc/source/qfcc.c | 20 +++---- tools/qfcc/source/qfprogs.c | 2 +- 20 files changed, 140 insertions(+), 146 deletions(-) diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 88a644f62..4ae88e18e 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -552,27 +552,21 @@ typedef struct pr_va_list_s { #define PROG_V6P_VERSION PROG_VERSION_ENCODE(0,fff,00a) #define PROG_VERSION PROG_VERSION_ENCODE(0,fff,010) +typedef struct pr_chunk_s { + pr_uint_t offset; + pr_uint_t count; +} pr_chunk_t; + typedef struct dprograms_s { pr_uint_t version; - pr_uint_t crc; // check of header file + pr_uint_t crc; // checksum of header file - pr_uint_t ofs_statements; - pr_uint_t numstatements; // statement 0 is an error - - pr_uint_t ofs_globaldefs; - pr_uint_t numglobaldefs; - - pr_uint_t ofs_fielddefs; - pr_uint_t numfielddefs; - - pr_uint_t ofs_functions; - pr_uint_t numfunctions; // function 0 is an empty - - pr_uint_t ofs_strings; - pr_uint_t numstrings; // first string is a null string - - pr_uint_t ofs_globals; - pr_uint_t numglobals; + pr_chunk_t statements; // statement 0 is an error + pr_chunk_t globaldefs; + pr_chunk_t fielddefs; + pr_chunk_t functions; // function 0 is an empty + pr_chunk_t strings; // first string is a null string, count is bytes + pr_chunk_t globals; pr_uint_t entityfields; } dprograms_t; diff --git a/libs/gamecode/pr_builtins.c b/libs/gamecode/pr_builtins.c index ab5088b9b..fcccb57a4 100644 --- a/libs/gamecode/pr_builtins.c +++ b/libs/gamecode/pr_builtins.c @@ -188,10 +188,10 @@ PR_RelocateBuiltins (progs_t *pr) if (pr->function_table) free (pr->function_table); - pr->function_table = calloc (pr->progs->numfunctions, + pr->function_table = calloc (pr->progs->functions.count, sizeof (bfunction_t)); - for (i = 1; i < pr->progs->numfunctions; i++) { + for (i = 1; i < pr->progs->functions.count; i++) { desc = pr->pr_functions + i; func = pr->function_table + i; diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index a30aa8c66..9eff304dd 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -549,12 +549,12 @@ PR_DebugSetSym (progs_t *pr, pr_debug_header_t *debug) res->debug_data = (pr_type_t*)((char*)debug + debug->debug_data); size_t size; - size = pr->progs->numfunctions * sizeof (pr_auxfunction_t *); + size = pr->progs->functions.count * sizeof (pr_auxfunction_t *); res->auxfunction_map = pr->allocate_progs_mem (pr, size); - size = pr->progs->numfunctions * sizeof (pr_func_t); + size = pr->progs->functions.count * sizeof (pr_func_t); res->sorted_functions = pr->allocate_progs_mem (pr, size); - for (pr_uint_t i = 0; i < pr->progs->numfunctions; i++) { + for (pr_uint_t i = 0; i < pr->progs->functions.count; i++) { res->auxfunction_map[i] = 0; res->sorted_functions[i] = i; } @@ -575,7 +575,7 @@ PR_DebugSetSym (progs_t *pr, pr_debug_header_t *debug) res->auxfunction_map[res->auxfunctions[i].function] = &res->auxfunctions[i]; } - qsort_r (res->sorted_functions, pr->progs->numfunctions, + qsort_r (res->sorted_functions, pr->progs->functions.count, sizeof (pr_func_t), func_compare_sort, res); for (pr_uint_t i = 0; i < debug->num_locals; i++) { @@ -733,7 +733,7 @@ VISIBLE pr_auxfunction_t * PR_Debug_MappedAuxFunction (progs_t *pr, pr_uint_t func) { prdeb_resources_t *res = pr->pr_debug_resources; - if (!res->debug || func >= pr->progs->numfunctions) { + if (!res->debug || func >= pr->progs->functions.count) { return 0; } return res->auxfunction_map[func]; @@ -841,7 +841,7 @@ PR_FindSourceLineAddr (progs_t *pr, const char *file, pr_uint_t line) prdeb_resources_t *res = pr->pr_debug_resources; func_key_t key = { file, line }; pr_func_t *f = fbsearch_r (&key, res->sorted_functions, - pr->progs->numfunctions, sizeof (pr_func_t), + pr->progs->functions.count, sizeof (pr_func_t), func_compare_search, res); if (!f) { return 0; @@ -878,7 +878,7 @@ PR_Get_Source_File (progs_t *pr, pr_lineno_t *lineno) pr_auxfunction_t *f; f = PR_Get_Lineno_Func (pr, lineno); - if (f->function >= (unsigned) pr->progs->numfunctions) + if (f->function >= (unsigned) pr->progs->functions.count) return 0; return PR_GetString(pr, pr->pr_functions[f->function].file); } @@ -1113,7 +1113,7 @@ pr_debug_find_def (progs_t *pr, pr_ptr_t *ofs) prdeb_resources_t *res = pr->pr_debug_resources; pr_def_t *def = 0; - if (*ofs >= pr->progs->numglobals) { + if (*ofs >= pr->progs->globals.count) { return 0; } if (pr_debug->int_val && res->debug) { @@ -1306,7 +1306,7 @@ pr_debug_func_view (qfot_type_t *type, pr_type_t *value, void *_data) progs_t *pr = data->pr; dstring_t *dstr = data->dstr; - if (value->func_var >= pr->progs->numfunctions) { + if (value->func_var >= pr->progs->functions.count) { dasprintf (dstr, "INVALID:%d", value->func_var); } else if (!value->func_var) { dstring_appendstr (dstr, "NULL"); @@ -1652,7 +1652,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) str = global_string (&data, opval, optype, contents & 1); func = G_FUNCTION (pr, opval); - if (func < pr->progs->numfunctions) { + if (func < pr->progs->functions.count) { call_func = pr->pr_functions + func; } break; @@ -1790,7 +1790,7 @@ PR_Profile (progs_t * pr) do { max = 0; best = NULL; - for (i = 0; i < pr->progs->numfunctions; i++) { + for (i = 0; i < pr->progs->functions.count; i++) { bf = &pr->function_table[i]; if (bf->profile > max) { max = bf->profile; @@ -1862,7 +1862,7 @@ ED_Print (progs_t *pr, edict_t *ed, const char *fieldname) } return; } - for (i = 0; i < pr->progs->numfielddefs; i++) { + for (i = 0; i < pr->progs->fielddefs.count; i++) { d = &pr->pr_fielddefs[i]; if (!d->name) // null field def (probably 1st) continue; diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index b0a81c376..3c0734617 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1459,7 +1459,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) break; case OP_JUMP_v6p: if (pr_boundscheck->int_val - && (OPA(uint) >= pr->progs->numstatements)) { + && (OPA(uint) >= pr->progs->statements.count)) { PR_RunError (pr, "Invalid jump destination"); } pr->pr_xstatement = OPA(uint) - 1; // offset the st++ @@ -1473,7 +1473,7 @@ pr_exec_quakec (progs_t *pr, int exitdepth) ptr = pr->pr_globals + pointer; pointer = ptr->int_var; if (pr_boundscheck->int_val - && (pointer >= pr->progs->numstatements)) { + && (pointer >= pr->progs->statements.count)) { PR_RunError (pr, "Invalid jump destination"); } pr->pr_xstatement = pointer - 1; // offset the st++ @@ -1874,7 +1874,7 @@ pr_jump_mode (progs_t *pr, const dstatement_t *st, int jump_ind) jump_offs = OPA(ptr) + OPB(int); break; } - if (pr_boundscheck->int_val && jump_offs >= pr->progs->numstatements) { + if (pr_boundscheck->int_val && jump_offs >= pr->progs->statements.count) { PR_RunError (pr, "out of bounds: %x", jump_offs); } return jump_offs - 1; // for st++ diff --git a/libs/gamecode/pr_load.c b/libs/gamecode/pr_load.c index 6d7116856..165ca789b 100644 --- a/libs/gamecode/pr_load.c +++ b/libs/gamecode/pr_load.c @@ -171,7 +171,7 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) // Some compilers (eg, FTE) put extra data between the header and the // strings section. What's worse, they de-align the data. - offset_tweak = progs.ofs_strings % sizeof (pr_int_t); + offset_tweak = progs.strings.offset % sizeof (pr_int_t); offset_tweak = (sizeof (pr_int_t) - offset_tweak) % sizeof (pr_int_t); // size of progs themselves @@ -216,14 +216,14 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) pr->zone = (memzone_t *) heap; } - pr->pr_functions = (dfunction_t *) (base + pr->progs->ofs_functions); - pr->pr_strings = (char *) base + pr->progs->ofs_strings; + pr->pr_functions = (dfunction_t *) (base + pr->progs->functions.offset); + pr->pr_strings = (char *) base + pr->progs->strings.offset; pr->pr_stringsize = (heap - base) + pr->zone_size; - global_ddefs = (ddef_t *) (base + pr->progs->ofs_globaldefs); - field_ddefs = (ddef_t *) (base + pr->progs->ofs_fielddefs); - pr->pr_statements = (dstatement_t *) (base + pr->progs->ofs_statements); + global_ddefs = (ddef_t *) (base + pr->progs->globaldefs.offset); + field_ddefs = (ddef_t *) (base + pr->progs->fielddefs.offset); + pr->pr_statements = (dstatement_t *) (base + pr->progs->statements.offset); - pr->pr_globals = (pr_type_t *) (base + pr->progs->ofs_globals); + pr->pr_globals = (pr_type_t *) (base + pr->progs->globals.offset); pr->stack = (pr_type_t *) ((byte *) pr->zone + pr->zone_size); pr->stack_bottom = pr->stack - pr->pr_globals; pr->globals_size = (pr_type_t *) ((byte *) pr->stack + pr->stack_size) @@ -241,14 +241,14 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) Hash_FlushTable (pr->field_hash); // byte swap the lumps - for (i = 0; i < pr->progs->numstatements; i++) { + for (i = 0; i < pr->progs->statements.count; i++) { pr->pr_statements[i].op = LittleShort (pr->pr_statements[i].op); pr->pr_statements[i].a = LittleShort (pr->pr_statements[i].a); pr->pr_statements[i].b = LittleShort (pr->pr_statements[i].b); pr->pr_statements[i].c = LittleShort (pr->pr_statements[i].c); } - for (i = 0; i < pr->progs->numfunctions; i++) { + for (i = 0; i < pr->progs->functions.count; i++) { pr->pr_functions[i].first_statement = LittleLong (pr->pr_functions[i].first_statement); pr->pr_functions[i].parm_start = @@ -265,9 +265,9 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) if (pr->pr_globaldefs) { free (pr->pr_globaldefs); } - pr->pr_globaldefs = calloc (pr->progs->numglobaldefs, sizeof (pr_def_t)); + pr->pr_globaldefs = calloc (pr->progs->globaldefs.count, sizeof (pr_def_t)); - for (i = 0; i < pr->progs->numglobaldefs; i++) { + for (i = 0; i < pr->progs->globaldefs.count; i++) { pr_ushort_t safe_type = global_ddefs[i].type & ~DEF_SAVEGLOBAL; global_ddefs[i].type = LittleShort (global_ddefs[i].type); global_ddefs[i].ofs = LittleShort (global_ddefs[i].ofs); @@ -283,8 +283,8 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) if (pr->pr_fielddefs) { free (pr->pr_fielddefs); } - pr->pr_fielddefs = calloc (pr->progs->numfielddefs, sizeof (pr_def_t)); - for (i = 0; i < pr->progs->numfielddefs; i++) { + pr->pr_fielddefs = calloc (pr->progs->fielddefs.count, sizeof (pr_def_t)); + for (i = 0; i < pr->progs->fielddefs.count; i++) { field_ddefs[i].type = LittleShort (field_ddefs[i].type); if (field_ddefs[i].type & DEF_SAVEGLOBAL) PR_Error (pr, "PR_LoadProgs: DEF_SAVEGLOBAL on field def %zd", i); @@ -297,7 +297,7 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) Hash_Add (pr->field_hash, &pr->pr_fielddefs[i]); } - for (i = 0; i < pr->progs->numglobals; i++) + for (i = 0; i < pr->progs->globals.count; i++) ((int *) pr->pr_globals)[i] = LittleLong (((int *) pr->pr_globals)[i]); xdefs_def = PR_FindGlobal (pr, ".xdefs"); @@ -305,23 +305,23 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) pr_xdefs_t *xdefs = &G_STRUCT (pr, pr_xdefs_t, xdefs_def->ofs); xdef_t *xdef = &G_STRUCT (pr, xdef_t, xdefs->xdefs); pr_def_t *def; - for (def = pr->pr_globaldefs, i = 0; i < pr->progs->numglobaldefs; + for (def = pr->pr_globaldefs, i = 0; i < pr->progs->globaldefs.count; i++, xdef++, def++) { def->ofs = xdef->ofs; def->type_encoding = xdef->type; } - for (def = pr->pr_fielddefs, i = 0; i < pr->progs->numfielddefs; + for (def = pr->pr_fielddefs, i = 0; i < pr->progs->fielddefs.count; i++, xdef++, def++) { def->ofs = xdef->ofs; def->type_encoding = xdef->type; } } else { pr_def_t *def; - for (def = pr->pr_globaldefs, i = 0; i < pr->progs->numglobaldefs; + for (def = pr->pr_globaldefs, i = 0; i < pr->progs->globaldefs.count; i++, def++) { def->size = pr_type_size[def->type & ~DEF_SAVEGLOBAL]; } - for (def = pr->pr_fielddefs, i = 0; i < pr->progs->numfielddefs; + for (def = pr->pr_fielddefs, i = 0; i < pr->progs->fielddefs.count; i++, def++) { def->size = pr_type_size[def->type & ~DEF_SAVEGLOBAL]; } @@ -369,7 +369,7 @@ pr_run_ctors (progs_t *pr) pr_uint_t fnum; dfunction_t *func; - for (fnum = 0; fnum < pr->progs->numfunctions; fnum++) { + for (fnum = 0; fnum < pr->progs->functions.count; fnum++) { func = pr->pr_functions + fnum; if (strequal (PR_GetString (pr, func->name), ".ctor")) PR_ExecuteProgram (pr, fnum); diff --git a/libs/gamecode/pr_parse.c b/libs/gamecode/pr_parse.c index 5f360c054..182146261 100644 --- a/libs/gamecode/pr_parse.c +++ b/libs/gamecode/pr_parse.c @@ -118,7 +118,7 @@ ED_EntityDict (progs_t *pr, edict_t *ed) pr_type_t *v; if (!ed->free) { - for (i = 0; i < pr->progs->numfielddefs; i++) { + for (i = 0; i < pr->progs->fielddefs.count; i++) { pr_def_t *d = &pr->pr_fielddefs[i]; name = PR_GetString (pr, d->name); @@ -162,7 +162,7 @@ ED_GlobalsDict (progs_t *pr) pr_def_t *def; int type; - for (i = 0; i < pr->progs->numglobaldefs; i++) { + for (i = 0; i < pr->progs->globaldefs.count; i++) { def = &pr->pr_globaldefs[i]; type = def->type; if (!(def->type & DEF_SAVEGLOBAL)) diff --git a/libs/gamecode/pr_resolve.c b/libs/gamecode/pr_resolve.c index 992aff74e..864baa443 100644 --- a/libs/gamecode/pr_resolve.c +++ b/libs/gamecode/pr_resolve.c @@ -71,13 +71,13 @@ PR_SearchDefs (pr_def_t *defs, unsigned num_defs, pr_ptr_t offset) pr_def_t * PR_GlobalAtOfs (progs_t * pr, pr_ptr_t ofs) { - return PR_SearchDefs (pr->pr_globaldefs, pr->progs->numglobaldefs, ofs); + return PR_SearchDefs (pr->pr_globaldefs, pr->progs->globaldefs.count, ofs); } VISIBLE pr_def_t * PR_FieldAtOfs (progs_t * pr, pr_ptr_t ofs) { - return PR_SearchDefs (pr->pr_fielddefs, pr->progs->numfielddefs, ofs); + return PR_SearchDefs (pr->pr_fielddefs, pr->progs->fielddefs.count, ofs); } VISIBLE pr_def_t * diff --git a/libs/gamecode/pr_strings.c b/libs/gamecode/pr_strings.c index 3c75984d2..b8364d89c 100644 --- a/libs/gamecode/pr_strings.c +++ b/libs/gamecode/pr_strings.c @@ -234,7 +234,7 @@ PR_LoadStrings (progs_t *pr) { prstr_resources_t *res = PR_Resources_Find (pr, "Strings"); - char *end = pr->pr_strings + pr->progs->numstrings; + char *end = pr->pr_strings + pr->progs->strings.count; char *str = pr->pr_strings; int count = 0; diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index 94da01a4c..13f129553 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -1493,7 +1493,7 @@ check_branch (progs_t *pr, dstatement_t *st, const v6p_opcode_t *op, short offse pr_int_t address = st - pr->pr_statements; address += offset; - if (address < 0 || (pr_uint_t) address >= pr->progs->numstatements) + if (address < 0 || (pr_uint_t) address >= pr->progs->statements.count) PR_Error (pr, "PR_Check_Opcodes: invalid branch (statement %ld: %s)", (long)(st - pr->pr_statements), op->opname); } @@ -1534,8 +1534,8 @@ check_global (progs_t *pr, dstatement_t *st, const v6p_opcode_t *op, etype_t typ break; default: if (operand + (unsigned) pr_type_size[type] - > pr->progs->numglobals) { - if (operand >= pr->progs->numglobals + > pr->progs->globals.count) { + if (operand >= pr->progs->globals.count || !is_vector_parameter_store (pr, st, operand)) { msg = "out of bounds global index"; goto error; @@ -1579,7 +1579,7 @@ check_global_size (progs_t *pr, dstatement_t *st, const v6p_opcode_t *op, unsigned short size, unsigned short operand) { const char *msg; - if (operand + size > pr->progs->numglobals) { + if (operand + size > pr->progs->globals.count) { msg = "out of bounds global index"; goto error; } @@ -1611,7 +1611,7 @@ PR_Check_v6p_Opcodes (progs_t *pr) // the only problem is that it slows progs load a little, but it's the only // way to check for qccx' evil if (0 && !pr_boundscheck->int_val) { - for (i = 0, st = pr->pr_statements; i < pr->progs->numstatements; + for (i = 0, st = pr->pr_statements; i < pr->progs->statements.count; st++, i++) { pr_opcode_v6p_e st_op = st->op; op = PR_v6p_Opcode (st_op); @@ -1632,7 +1632,7 @@ PR_Check_v6p_Opcodes (progs_t *pr) } } } else { - for (i = 0, st = pr->pr_statements; i < pr->progs->numstatements; + for (i = 0, st = pr->pr_statements; i < pr->progs->statements.count; st++, i++) { pr_opcode_v6p_e st_op = st->op; op = PR_v6p_Opcode (st_op); diff --git a/libs/gamecode/test/main.c b/libs/gamecode/test/main.c index 9f988fd50..bb0efb2fd 100644 --- a/libs/gamecode/test/main.c +++ b/libs/gamecode/test/main.c @@ -132,7 +132,7 @@ setup_test (test_t *test) } } - test_progs.numstatements = test->num_statements + 1; + test_progs.statements.count = test->num_statements + 1; test_pr.pr_statements = malloc ((test->num_statements + 1) * sizeof (dstatement_t)); memcpy (test_pr.pr_statements, test->statements, diff --git a/ruamoko/qwaq/builtins/debug.c b/ruamoko/qwaq/builtins/debug.c index c9da1e923..10c09c136 100644 --- a/ruamoko/qwaq/builtins/debug.c +++ b/ruamoko/qwaq/builtins/debug.c @@ -221,7 +221,7 @@ qdb_set_breakpoint (progs_t *pr) qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; - if (staddr >= tpr->progs->numstatements) { + if (staddr >= tpr->progs->statements.count) { R_INT (pr) = -1; return; } @@ -239,7 +239,7 @@ qdb_clear_breakpoint (progs_t *pr) qwaq_target_t *target = get_target (debug, __FUNCTION__, handle); progs_t *tpr = target->pr; - if (staddr >= tpr->progs->numstatements) { + if (staddr >= tpr->progs->statements.count) { R_INT (pr) = -1; return; } @@ -555,7 +555,7 @@ qdb_get_function (progs_t *pr) pr_uint_t fnum = P_INT (pr, 1); dfunction_t *func = tpr->pr_functions + fnum; - if (fnum >= tpr->progs->numfunctions) { + if (fnum >= tpr->progs->functions.count) { func = 0; } return_function (pr, func); @@ -591,7 +591,7 @@ qdb_find_auxfunction (progs_t *pr) pr_uint_t fnum = func - tpr->pr_functions; pr_auxfunction_t *auxfunc = PR_Debug_MappedAuxFunction (tpr, fnum); - if (fnum >= tpr->progs->numfunctions) { + if (fnum >= tpr->progs->functions.count) { func = 0; } return_auxfunction (pr, auxfunc); diff --git a/tools/qfcc/source/disassemble.c b/tools/qfcc/source/disassemble.c index 60e4765bc..953ab8143 100644 --- a/tools/qfcc/source/disassemble.c +++ b/tools/qfcc/source/disassemble.c @@ -63,7 +63,7 @@ disassemble_progs (progs_t *pr) { unsigned int i; - for (i = 0; i < pr->progs->numstatements; i++) { + for (i = 0; i < pr->progs->statements.count; i++) { dfunction_t *desc = func_find (i); if (desc) { diff --git a/tools/qfcc/source/dump_globals.c b/tools/qfcc/source/dump_globals.c index 69cc1e61a..256c5e9d6 100644 --- a/tools/qfcc/source/dump_globals.c +++ b/tools/qfcc/source/dump_globals.c @@ -79,7 +79,7 @@ dump_def (progs_t *pr, pr_def_t *def, int indent) comment = " invalid offset"; - if (offset < pr->progs->numglobals) { + if (offset < pr->progs->globals.count) { comment = ""; switch (def->type & ~DEF_SAVEGLOBAL) { case ev_void: @@ -91,7 +91,7 @@ dump_def (progs_t *pr, pr_def_t *def, int indent) // dynamically allocated, thus a negative string index should // never appear in compiled code if (string < 0 - || (pr_uint_t) string >= pr->progs->numstrings) { + || (pr_uint_t) string >= pr->progs->strings.count) { str = "invalid string offset"; comment = va (0, " %d %s", string, str); } else { @@ -120,7 +120,7 @@ dump_def (progs_t *pr, pr_def_t *def, int indent) { pr_func_t func = G_FUNCTION (pr, offset); int start; - if (func < pr->progs->numfunctions) { + if (func < pr->progs->functions.count) { start = pr->pr_functions[func].first_statement; if (start > 0) comment = va (0, " %d @ %x", func, start); @@ -165,12 +165,12 @@ dump_globals (progs_t *pr) pr_def_t *global_defs = pr->pr_globaldefs; if (sorted) { - global_defs = malloc (pr->progs->numglobaldefs * sizeof (ddef_t)); + global_defs = malloc (pr->progs->globaldefs.count * sizeof (ddef_t)); memcpy (global_defs, pr->pr_globaldefs, - pr->progs->numglobaldefs * sizeof (ddef_t)); - qsort (global_defs, pr->progs->numglobaldefs, sizeof (ddef_t), cmp); + pr->progs->globaldefs.count * sizeof (ddef_t)); + qsort (global_defs, pr->progs->globaldefs.count, sizeof (ddef_t), cmp); } - for (i = 0; i < pr->progs->numglobaldefs; i++) { + for (i = 0; i < pr->progs->globaldefs.count; i++) { pr_def_t *def = &global_defs[i]; dump_def (pr, def, 0); } @@ -185,7 +185,7 @@ dump_fields (progs_t *pr) int offset; const char *comment; - for (i = 0; i < pr->progs->numfielddefs; i++) { + for (i = 0; i < pr->progs->fielddefs.count; i++) { pr_def_t *def = &pr->pr_fielddefs[i]; name = PR_GetString (pr, def->name); @@ -248,7 +248,7 @@ dump_functions (progs_t *pr) type_encodings = encodings_def->ofs; } - for (i = 0; i < pr->progs->numfunctions; i++) { + for (i = 0; i < pr->progs->functions.count; i++) { dfunction_t *func = &pr->pr_functions[i]; name = PR_GetString (pr, func->name); diff --git a/tools/qfcc/source/dump_lines.c b/tools/qfcc/source/dump_lines.c index f021e48a3..4b95b3ad3 100644 --- a/tools/qfcc/source/dump_lines.c +++ b/tools/qfcc/source/dump_lines.c @@ -78,7 +78,7 @@ progs_get_func_data (unsigned func_index, void *data) func_data.local_defs = aux_func->local_defs; func_data.line_info = aux_func->line_info; func_data.function = aux_func->function; - if (aux_func->function < (unsigned int) pr->progs->numfunctions) { + if (aux_func->function < (unsigned int) pr->progs->functions.count) { func = pr->pr_functions + aux_func->function; func_data.source_file = pr->pr_strings + func->file; func_data.source_name = pr->pr_strings + func->name; diff --git a/tools/qfcc/source/dump_modules.c b/tools/qfcc/source/dump_modules.c index 5f0f590f2..70dfe35c0 100644 --- a/tools/qfcc/source/dump_modules.c +++ b/tools/qfcc/source/dump_modules.c @@ -277,7 +277,7 @@ dump_modules (progs_t *pr) { unsigned int i; - for (i = 0; i < pr->progs->numglobaldefs; i++) { + for (i = 0; i < pr->progs->globaldefs.count; i++) { pr_def_t *def = &pr->pr_globaldefs[i]; const char *name = ""; diff --git a/tools/qfcc/source/dump_strings.c b/tools/qfcc/source/dump_strings.c index c8507011e..df4ca1b04 100644 --- a/tools/qfcc/source/dump_strings.c +++ b/tools/qfcc/source/dump_strings.c @@ -78,7 +78,7 @@ dump_string_block (const char *strblock, size_t size) void dump_strings (progs_t *pr) { - dump_string_block (pr->pr_strings, pr->progs->numstrings); + dump_string_block (pr->pr_strings, pr->progs->strings.count); } void diff --git a/tools/qfcc/source/idstuff.c b/tools/qfcc/source/idstuff.c index 9fb7f5003..34e9c4d7b 100644 --- a/tools/qfcc/source/idstuff.c +++ b/tools/qfcc/source/idstuff.c @@ -212,9 +212,9 @@ WriteProgdefs (dprograms_t *progs, const char *filename) "\n\ntypedef struct\n{\tint\tpad[%i];\n", RESERVED_OFS); - strings = (char *) progs + progs->ofs_strings; - for (i = 0; i < progs->numglobaldefs; i++) { - def = (ddef_t *) ((char *) progs + progs->ofs_globaldefs) + i; + strings = (char *) progs + progs->strings.offset; + for (i = 0; i < progs->globaldefs.count; i++) { + def = (ddef_t *) ((char *) progs + progs->globaldefs.offset) + i; name = strings + def->name; if (!strcmp (name, "end_sys_globals")) break; @@ -251,8 +251,8 @@ WriteProgdefs (dprograms_t *progs, const char *filename) // print all fields dasprintf (dstr, "typedef struct\n{\n"); - for (i = 0, j = 0; i < progs->numglobaldefs; i++) { - def = (ddef_t *) ((char *) progs + progs->ofs_globaldefs) + i; + for (i = 0, j = 0; i < progs->globaldefs.count; i++) { + def = (ddef_t *) ((char *) progs + progs->globaldefs.offset) + i; name = strings + def->name; if (!strcmp (name, "end_sys_fields")) break; @@ -264,7 +264,7 @@ WriteProgdefs (dprograms_t *progs, const char *filename) if (!strcmp (name, ".imm")) continue; - fdef = (ddef_t *) ((char *) progs + progs->ofs_fielddefs) + j++; + fdef = (ddef_t *) ((char *) progs + progs->fielddefs.offset) + j++; if (fdef->name != def->name) internal_error (0, "def and field order messup"); diff --git a/tools/qfcc/source/obj_file.c b/tools/qfcc/source/obj_file.c index 6a53b32ab..fa650a822 100644 --- a/tools/qfcc/source/obj_file.c +++ b/tools/qfcc/source/obj_file.c @@ -970,18 +970,18 @@ qfo_to_progs (qfo_t *in_qfo, int *size) *size = RUP (sizeof (dprograms_t), 16); progs = calloc (1, *size); progs->version = options.code.progsversion; - progs->numstatements = qfo->spaces[qfo_code_space].data_size; - progs->numglobaldefs = qfo->spaces[qfo_near_data_space].num_defs; + progs->statements.count = qfo->spaces[qfo_code_space].data_size; + progs->globaldefs.count = qfo->spaces[qfo_near_data_space].num_defs; //ddef offsets are 16 bits so the ddef ofs will likely be invalid //thus it will be forced invalid and the true offset written to the //.xdefs array in the progs file - progs->numglobaldefs += qfo->spaces[qfo_far_data_space].num_defs; - progs->numfielddefs = qfo->spaces[qfo_entity_space].num_defs; - progs->numfunctions = qfo->num_funcs + 1; - progs->numstrings = qfo->spaces[qfo_strings_space].data_size; - progs->numglobals = qfo->spaces[qfo_near_data_space].data_size; - progs->numglobals = align_globals_size (progs->numglobals); - locals_start = progs->numglobals; + progs->globaldefs.count += qfo->spaces[qfo_far_data_space].num_defs; + progs->fielddefs.count = qfo->spaces[qfo_entity_space].num_defs; + progs->functions.count = qfo->num_funcs + 1; + progs->strings.count = qfo->spaces[qfo_strings_space].data_size; + progs->globals.count = qfo->spaces[qfo_near_data_space].data_size; + progs->globals.count = align_globals_size (progs->globals.count); + locals_start = progs->globals.count; if (options.code.progsversion < PROG_VERSION) { for (i = qfo_num_spaces; i < qfo->num_spaces; i++) { if (options.code.local_merging) { @@ -994,34 +994,34 @@ qfo_to_progs (qfo_t *in_qfo, int *size) } } } - progs->numglobals += locals_size; - near_data_size = progs->numglobals; - progs->numglobals = RUP (progs->numglobals, 16 / sizeof (pr_type_t)); - progs->numglobals += qfo->spaces[qfo_far_data_space].data_size; - type_encodings_start = progs->numglobals; - progs->numglobals += qfo->spaces[qfo_type_space].data_size; - progs->numglobals = RUP (progs->numglobals, type_xdef.alignment); - xdefs_start = progs->numglobals; - progs->numglobals += progs->numglobaldefs * type_size (&type_xdef); - progs->numglobals += progs->numfielddefs * type_size (&type_xdef); + progs->globals.count += locals_size; + near_data_size = progs->globals.count; + progs->globals.count = RUP (progs->globals.count, 16 / sizeof (pr_type_t)); + progs->globals.count += qfo->spaces[qfo_far_data_space].data_size; + type_encodings_start = progs->globals.count; + progs->globals.count += qfo->spaces[qfo_type_space].data_size; + progs->globals.count = RUP (progs->globals.count, type_xdef.alignment); + xdefs_start = progs->globals.count; + progs->globals.count += progs->globaldefs.count * type_size (&type_xdef); + progs->globals.count += progs->fielddefs.count * type_size (&type_xdef); progs->entityfields = qfo->spaces[qfo_entity_space].data_size; // qfo_debug_space does not go in the progs file - *size += progs->numstatements * sizeof (dstatement_t); - *size += progs->numglobaldefs * sizeof (ddef_t); - *size += progs->numfielddefs * sizeof (ddef_t); - *size += progs->numfunctions * sizeof (dfunction_t); - *size += RUP (progs->numstrings * sizeof (char), 16); - *size += progs->numglobals * sizeof (pr_type_t); + *size += progs->statements.count * sizeof (dstatement_t); + *size += progs->globaldefs.count * sizeof (ddef_t); + *size += progs->fielddefs.count * sizeof (ddef_t); + *size += progs->functions.count * sizeof (dfunction_t); + *size += RUP (progs->strings.count * sizeof (char), 16); + *size += progs->globals.count * sizeof (pr_type_t); progs = realloc (progs, *size); data = (byte *) progs; memset (progs + 1, 0, *size - sizeof (dprograms_t)); data += RUP (sizeof (dprograms_t), 16); - def_indices = alloca ((progs->numglobaldefs + progs->numfielddefs) + def_indices = alloca ((progs->globaldefs.count + progs->fielddefs.count) * sizeof (*def_indices)); far_def_indices = def_indices + qfo->spaces[qfo_near_data_space].num_defs; - field_def_indices = def_indices + progs->numglobaldefs; + field_def_indices = def_indices + progs->globaldefs.count; for (unsigned i = 0; i < qfo->spaces[qfo_near_data_space].num_defs; i++) { def_indices[i] = i; } @@ -1041,28 +1041,28 @@ qfo_to_progs (qfo_t *in_qfo, int *size) sizeof (unsigned), qfo_def_compare, qfo->spaces[qfo_entity_space].defs); - progs->ofs_strings = data - (byte *) progs; + progs->strings.offset = data - (byte *) progs; strings = (char *) data; - data += RUP (progs->numstrings * sizeof (char), 16); + data += RUP (progs->strings.count * sizeof (char), 16); - progs->ofs_statements = data - (byte *) progs; + progs->statements.offset = data - (byte *) progs; statements = (dstatement_t *) data; - data += progs->numstatements * sizeof (dstatement_t); + data += progs->statements.count * sizeof (dstatement_t); - progs->ofs_functions = data - (byte *) progs; + progs->functions.offset = data - (byte *) progs; functions = (dfunction_t *) data; functions++; // skip over null function - data += progs->numfunctions * sizeof (dfunction_t); + data += progs->functions.count * sizeof (dfunction_t); - progs->ofs_globaldefs = data - (byte *) progs; + progs->globaldefs.offset = data - (byte *) progs; globaldefs = (ddef_t *) data; - data += progs->numglobaldefs * sizeof (ddef_t); + data += progs->globaldefs.count * sizeof (ddef_t); - progs->ofs_fielddefs = data - (byte *) progs; - fielddefs = (ddef_t *) (globaldefs + progs->numglobaldefs); - data += progs->numfielddefs * sizeof (ddef_t); + progs->fielddefs.offset = data - (byte *) progs; + fielddefs = (ddef_t *) (globaldefs + progs->globaldefs.count); + data += progs->fielddefs.count * sizeof (ddef_t); - progs->ofs_globals = data - (byte *) progs; + progs->globals.offset = data - (byte *) progs; globals = (pr_type_t*) data; locals = globals + locals_start; far_data = globals + near_data_size; @@ -1155,7 +1155,7 @@ qfo_to_progs (qfo_t *in_qfo, int *size) xdefs = (pr_xdefs_t *) &globals[xdefs_def->offset]; xdef = (xdef_t *) xdef_data; xdefs->xdefs = xdefs_start; - xdefs->num_xdefs = progs->numglobaldefs + progs->numfielddefs; + xdefs->num_xdefs = progs->globaldefs.count + progs->fielddefs.count; for (i = 0; i < qfo->spaces[qfo_near_data_space].num_defs; i++, xdef++) { qfo_def_t *def = qfo->spaces[qfo_near_data_space].defs + i; @@ -1193,12 +1193,12 @@ qfo_to_progs (qfo_t *in_qfo, int *size) const char *big_function = ""; if (big_func) big_function = va (0, " (%s)", strings + qfo->funcs[big_func].name); - printf ("%6i strofs\n", progs->numstrings); - printf ("%6i statements\n", progs->numstatements); - printf ("%6i functions\n", progs->numfunctions); - printf ("%6i global defs\n", progs->numglobaldefs); - printf ("%6i field defs\n", progs->numfielddefs); - printf ("%6i globals\n", progs->numglobals); + printf ("%6i strofs\n", progs->strings.count); + printf ("%6i statements\n", progs->statements.count); + printf ("%6i functions\n", progs->functions.count); + printf ("%6i global defs\n", progs->globaldefs.count); + printf ("%6i field defs\n", progs->fielddefs.count); + printf ("%6i globals\n", progs->globals.count); printf (" %6i near globals\n", near_data_size); printf (" %6i locals size%s\n", locals_size, big_function); printf (" %6i far globals\n", diff --git a/tools/qfcc/source/qfcc.c b/tools/qfcc/source/qfcc.c index 134890dea..ae256c8cf 100644 --- a/tools/qfcc/source/qfcc.c +++ b/tools/qfcc/source/qfcc.c @@ -212,20 +212,20 @@ WriteProgs (dprograms_t *progs, int size) pr_type_t *globals; #define P(t,o) ((t *)((char *)progs + progs->o)) - statements = P (dstatement_t, ofs_statements); - functions = P (dfunction_t, ofs_functions); - globaldefs = P (ddef_t, ofs_globaldefs); - fielddefs = P (ddef_t, ofs_fielddefs); - globals = P (pr_type_t, ofs_globals); + statements = P (dstatement_t, statements.offset); + functions = P (dfunction_t, functions.offset); + globaldefs = P (ddef_t, globaldefs.offset); + fielddefs = P (ddef_t, fielddefs.offset); + globals = P (pr_type_t, globals.offset); #undef P - for (i = 0; i < progs->numstatements; i++) { + for (i = 0; i < progs->statements.count; i++) { statements[i].op = LittleShort (statements[i].op); statements[i].a = LittleShort (statements[i].a); statements[i].b = LittleShort (statements[i].b); statements[i].c = LittleShort (statements[i].c); } - for (i = 0; i < (unsigned) progs->numfunctions; i++) { + for (i = 0; i < (unsigned) progs->functions.count; i++) { dfunction_t *func = functions + i; func->first_statement = LittleLong (func->first_statement); func->parm_start = LittleLong (func->parm_start); @@ -235,17 +235,17 @@ WriteProgs (dprograms_t *progs, int size) func->file = LittleLong (func->file); func->numparms = LittleLong (func->numparms); } - for (i = 0; i < progs->numglobaldefs; i++) { + for (i = 0; i < progs->globaldefs.count; i++) { globaldefs[i].type = LittleShort (globaldefs[i].type); globaldefs[i].ofs = LittleShort (globaldefs[i].ofs); globaldefs[i].name = LittleLong (globaldefs[i].name); } - for (i = 0; i < progs->numfielddefs; i++) { + for (i = 0; i < progs->fielddefs.count; i++) { fielddefs[i].type = LittleShort (fielddefs[i].type); fielddefs[i].ofs = LittleShort (fielddefs[i].ofs); fielddefs[i].name = LittleLong (fielddefs[i].name); } - for (i = 0; i < progs->numglobals; i++) + for (i = 0; i < progs->globals.count; i++) globals[i].int_var = LittleLong (globals[i].int_var); if (!(h = Qopen (options.output_file, "wb"))) diff --git a/tools/qfcc/source/qfprogs.c b/tools/qfcc/source/qfprogs.c index 1d60336a4..b468cc5b3 100644 --- a/tools/qfcc/source/qfprogs.c +++ b/tools/qfcc/source/qfprogs.c @@ -293,7 +293,7 @@ load_progs (const char *name) PR_LoadStrings (&pr); PR_LoadDebug (&pr); } - for (i = 0; i < pr.progs->numfunctions; i++) { + for (i = 0; i < pr.progs->functions.count; i++) { // don't bother with builtins if (pr.pr_functions[i].first_statement > 0) Hash_AddElement (func_tab, &pr.pr_functions[i]); From 169b8cc398b8082af5464fb725f56d0cabbdd034 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 26 Jan 2022 23:18:15 +0900 Subject: [PATCH 232/360] [qfcc] Rewrite qfo_to_progs offset/size calculation This gets all the sections of the progs file nicely aligned and the code easier to read with the offset and size calculations not being spread through the function. ivar-struct-return now works when compiled for Ruamoko. --- tools/qfcc/include/obj_file.h | 20 +-- tools/qfcc/source/obj_file.c | 228 +++++++++++++++++++++------------- 2 files changed, 153 insertions(+), 95 deletions(-) diff --git a/tools/qfcc/include/obj_file.h b/tools/qfcc/include/obj_file.h index a4861d29a..b827d58a1 100644 --- a/tools/qfcc/include/obj_file.h +++ b/tools/qfcc/include/obj_file.h @@ -249,14 +249,14 @@ typedef struct qfo_reloc_s { typedef struct qfo_mspace_s { qfos_type_t type; qfo_def_t *defs; - unsigned num_defs; + pr_uint_t num_defs; union { dstatement_t *code; pr_type_t *data; char *strings; }; - unsigned data_size; - unsigned id; + pr_uint_t data_size; + pr_uint_t id; } qfo_mspace_t; /** In-memory representation of a QFO object file. @@ -265,16 +265,16 @@ typedef struct qfo_s { pr_uint_t progs_version; ///< version of compatible VM void *data; ///< data buffer holding qfo file when read qfo_mspace_t *spaces; - unsigned num_spaces; + pr_uint_t num_spaces; qfo_reloc_t *relocs; - unsigned num_relocs; // includes num_loose_relocs + pr_uint_t num_relocs; // includes num_loose_relocs qfo_def_t *defs; - unsigned num_defs; + pr_uint_t num_defs; qfo_func_t *funcs; - unsigned num_funcs; + pr_uint_t num_funcs; pr_lineno_t *lines; - unsigned num_lines; - unsigned num_loose_relocs; // included in num_relocs + pr_uint_t num_lines; + pr_uint_t num_loose_relocs; // included in num_relocs } qfo_t; enum { @@ -500,7 +500,7 @@ qfo_t *qfo_new (void); */ void qfo_delete (qfo_t *qfo); -__attribute__((const)) int qfo_log2 (unsigned x); +__attribute__((const)) int qfo_log2 (pr_uint_t x); ///@} diff --git a/tools/qfcc/source/obj_file.c b/tools/qfcc/source/obj_file.c index fa650a822..a672a41fa 100644 --- a/tools/qfcc/source/obj_file.c +++ b/tools/qfcc/source/obj_file.c @@ -918,7 +918,7 @@ align_globals_size (unsigned size) } static int -qfo_def_compare (const void *i1, const void *i2, void *d) +qfo_def_offset_compare (const void *i1, const void *i2, void *d) { __auto_type defs = (const qfo_def_t *) d; unsigned ind1 = *(unsigned *) i1; @@ -928,10 +928,79 @@ qfo_def_compare (const void *i1, const void *i2, void *d) return def1->offset - def2->offset; } +static pr_uint_t +qfo_count_locals (const qfo_t *qfo, pr_uint_t *big_locals) +{ + if (options.code.progsversion == PROG_VERSION) { + // Ruamoko progs keep their locals on the stack rather than a + // "protected" area in the globals + *big_locals = 0; + return 0; + } + + pr_uint_t locals_size = 0; + for (pr_uint_t i = qfo_num_spaces; i < qfo->num_spaces; i++) { + if (options.code.local_merging) { + if (locals_size < qfo->spaces[i].data_size) { + locals_size = qfo->spaces[i].data_size; + *big_locals = i; + } + } else { + locals_size += align_globals_size (qfo->spaces[i].data_size); + } + } + return locals_size; +} + +typedef struct globals_info_s { + pr_uint_t locals_start; + pr_uint_t locals_size; + pr_uint_t big_locals; + pr_uint_t near_data_size; + pr_uint_t type_encodings_start; + pr_uint_t xdefs_start; + pr_uint_t xdefs_size; + pr_uint_t globals_size; +} globals_info_t; + + +static globals_info_t +qfo_count_globals (qfo_t *qfo, dprograms_t *progs, int word_align) +{ + globals_info_t info = {}; + info.globals_size = qfo->spaces[qfo_near_data_space].data_size; + info.globals_size = RUP (info.globals_size, word_align); + + info.locals_start = info.globals_size; + info.locals_size = qfo_count_locals (qfo, &info.big_locals); + info.globals_size += info.locals_size; + info.near_data_size = info.globals_size; + + info.globals_size = RUP (info.globals_size, word_align); + info.globals_size += qfo->spaces[qfo_far_data_space].data_size; + + info.type_encodings_start = info.globals_size; + info.globals_size += qfo->spaces[qfo_type_space].data_size; + info.globals_size = RUP (info.globals_size, type_xdef.alignment); + + info.xdefs_start = info.globals_size; + info.xdefs_size = progs->globaldefs.count + progs->fielddefs.count; + info.xdefs_size *= type_size (&type_xdef); + info.globals_size += info.xdefs_size; + + return info; +} + +static pr_uint_t +qfo_next_offset (pr_chunk_t chunk, pr_uint_t size, pr_uint_t align) +{ + size *= chunk.count; + return RUP (chunk.offset + size, align); +} + dprograms_t * qfo_to_progs (qfo_t *in_qfo, int *size) { - byte *data; char *strings; dstatement_t *statements; dfunction_t *functions; @@ -946,12 +1015,6 @@ qfo_to_progs (qfo_t *in_qfo, int *size) qfo_def_t *types_def = 0; qfo_def_t *xdefs_def = 0; unsigned i, j; - unsigned near_data_size = 0; - unsigned locals_size = 0; - int locals_start; - int type_encodings_start; - int xdefs_start; - unsigned big_locals = 0; int big_func = 0; pr_xdefs_t *xdefs = 0; xdef_t *xdef; @@ -959,6 +1022,16 @@ qfo_to_progs (qfo_t *in_qfo, int *size) unsigned *far_def_indices; unsigned *field_def_indices; + // id progs were aligned to only 4 bytes, but 8 is much more reasonable + pr_uint_t byte_align = 8; + if (options.code.progsversion == PROG_VERSION) { + byte_align = __alignof__ (pr_lvec4_t); + } else if (options.code.progsversion == PROG_V6P_VERSION) { + byte_align = 16; + } + pr_uint_t word_align = byte_align / sizeof (pr_int_t); + + qfo_t *qfo = alloca (sizeof (qfo_t) + in_qfo->num_spaces * sizeof (qfo_mspace_t)); *qfo = *in_qfo; @@ -970,53 +1043,52 @@ qfo_to_progs (qfo_t *in_qfo, int *size) *size = RUP (sizeof (dprograms_t), 16); progs = calloc (1, *size); progs->version = options.code.progsversion; + // crc is set in qfcc.c if enabled + + // these are in order in which they usually appear in the file rather + // than the order they appear in the struct, though with the offsets + // it doesn't matter too much. However, as people expect a certain + // layout, ti does matter enough to preserve the traditional file order. + progs->strings.offset = *size; + progs->strings.count = qfo->spaces[qfo_strings_space].data_size; + + progs->statements.offset = qfo_next_offset (progs->strings, + sizeof (char), + byte_align); progs->statements.count = qfo->spaces[qfo_code_space].data_size; + + progs->functions.offset = qfo_next_offset (progs->statements, + sizeof (dstatement_t), + byte_align); + progs->functions.count = qfo->num_funcs + 1; + + progs->globaldefs.offset = qfo_next_offset (progs->functions, + sizeof (dfunction_t), + byte_align); progs->globaldefs.count = qfo->spaces[qfo_near_data_space].num_defs; //ddef offsets are 16 bits so the ddef ofs will likely be invalid //thus it will be forced invalid and the true offset written to the //.xdefs array in the progs file progs->globaldefs.count += qfo->spaces[qfo_far_data_space].num_defs; + + progs->fielddefs.offset = qfo_next_offset (progs->globaldefs, + sizeof (ddef_t), + byte_align); progs->fielddefs.count = qfo->spaces[qfo_entity_space].num_defs; - progs->functions.count = qfo->num_funcs + 1; - progs->strings.count = qfo->spaces[qfo_strings_space].data_size; - progs->globals.count = qfo->spaces[qfo_near_data_space].data_size; - progs->globals.count = align_globals_size (progs->globals.count); - locals_start = progs->globals.count; - if (options.code.progsversion < PROG_VERSION) { - for (i = qfo_num_spaces; i < qfo->num_spaces; i++) { - if (options.code.local_merging) { - if (locals_size < qfo->spaces[i].data_size) { - locals_size = qfo->spaces[i].data_size; - big_locals = i; - } - } else { - locals_size += align_globals_size (qfo->spaces[i].data_size); - } - } - } - progs->globals.count += locals_size; - near_data_size = progs->globals.count; - progs->globals.count = RUP (progs->globals.count, 16 / sizeof (pr_type_t)); - progs->globals.count += qfo->spaces[qfo_far_data_space].data_size; - type_encodings_start = progs->globals.count; - progs->globals.count += qfo->spaces[qfo_type_space].data_size; - progs->globals.count = RUP (progs->globals.count, type_xdef.alignment); - xdefs_start = progs->globals.count; - progs->globals.count += progs->globaldefs.count * type_size (&type_xdef); - progs->globals.count += progs->fielddefs.count * type_size (&type_xdef); + + progs->globals.offset = qfo_next_offset (progs->fielddefs, + sizeof (ddef_t), + byte_align); + globals_info_t globals_info = qfo_count_globals (qfo, progs, word_align); + progs->globals.count = globals_info.globals_size; + progs->entityfields = qfo->spaces[qfo_entity_space].data_size; // qfo_debug_space does not go in the progs file - *size += progs->statements.count * sizeof (dstatement_t); - *size += progs->globaldefs.count * sizeof (ddef_t); - *size += progs->fielddefs.count * sizeof (ddef_t); - *size += progs->functions.count * sizeof (dfunction_t); - *size += RUP (progs->strings.count * sizeof (char), 16); - *size += progs->globals.count * sizeof (pr_type_t); + + *size = qfo_next_offset (progs->globals, sizeof (pr_type_t), 1); progs = realloc (progs, *size); - data = (byte *) progs; memset (progs + 1, 0, *size - sizeof (dprograms_t)); - data += RUP (sizeof (dprograms_t), 16); def_indices = alloca ((progs->globaldefs.count + progs->fielddefs.count) * sizeof (*def_indices)); @@ -1032,42 +1104,27 @@ qfo_to_progs (qfo_t *in_qfo, int *size) field_def_indices[i] = i; } qsort_r (def_indices, qfo->spaces[qfo_near_data_space].num_defs, - sizeof (unsigned), qfo_def_compare, + sizeof (unsigned), qfo_def_offset_compare, qfo->spaces[qfo_near_data_space].defs); qsort_r (far_def_indices, qfo->spaces[qfo_far_data_space].num_defs, - sizeof (unsigned), qfo_def_compare, + sizeof (unsigned), qfo_def_offset_compare, qfo->spaces[qfo_far_data_space].defs); qsort_r (field_def_indices, qfo->spaces[qfo_entity_space].num_defs, - sizeof (unsigned), qfo_def_compare, + sizeof (unsigned), qfo_def_offset_compare, qfo->spaces[qfo_entity_space].defs); - progs->strings.offset = data - (byte *) progs; - strings = (char *) data; - data += RUP (progs->strings.count * sizeof (char), 16); - - progs->statements.offset = data - (byte *) progs; - statements = (dstatement_t *) data; - data += progs->statements.count * sizeof (dstatement_t); - - progs->functions.offset = data - (byte *) progs; - functions = (dfunction_t *) data; +#define qfo_block(t,b) (t *) ((byte *) progs + progs->b.offset) + strings = qfo_block (char, strings); + statements = qfo_block (dstatement_t, statements); + functions = qfo_block (dfunction_t, functions); functions++; // skip over null function - data += progs->functions.count * sizeof (dfunction_t); - - progs->globaldefs.offset = data - (byte *) progs; - globaldefs = (ddef_t *) data; - data += progs->globaldefs.count * sizeof (ddef_t); - - progs->fielddefs.offset = data - (byte *) progs; - fielddefs = (ddef_t *) (globaldefs + progs->globaldefs.count); - data += progs->fielddefs.count * sizeof (ddef_t); - - progs->globals.offset = data - (byte *) progs; - globals = (pr_type_t*) data; - locals = globals + locals_start; - far_data = globals + near_data_size; - type_data = globals + type_encodings_start; - xdef_data = globals + xdefs_start; + globaldefs = qfo_block (ddef_t, globaldefs); + fielddefs = qfo_block (ddef_t, fielddefs); + globals = qfo_block (pr_type_t, globals); + locals = globals + globals_info.locals_start; + far_data = globals + globals_info.near_data_size; + type_data = globals + globals_info.type_encodings_start; + xdef_data = globals + globals_info.xdefs_start; memcpy (strings, qfo->spaces[qfo_strings_space].strings, qfo->spaces[qfo_strings_space].data_size * sizeof (char)); @@ -1084,13 +1141,13 @@ qfo_to_progs (qfo_t *in_qfo, int *size) df->first_statement = qf->code; if (options.code.progsversion < PROG_VERSION) { - df->parm_start = locals_start; + df->parm_start = globals_info.locals_start; df->locals = space->data_size; // finalize the offsets of the local defs for (j = 0; j < space->num_defs; j++) - space->defs[j].offset += locals_start; + space->defs[j].offset += globals_info.locals_start; if (!options.code.local_merging) - locals_start += align_globals_size (df->locals); + globals_info.locals_start += align_globals_size (df->locals); } df->profile = 0; df->name = qf->name; @@ -1120,7 +1177,7 @@ qfo_to_progs (qfo_t *in_qfo, int *size) } for (i = 0; i < qfo->spaces[qfo_type_space].num_defs; i++) { - qfo->spaces[qfo_type_space].defs[i].offset += type_encodings_start; + qfo->spaces[qfo_type_space].defs[i].offset += globals_info.type_encodings_start; } for (i = 0; i < qfo->spaces[qfo_entity_space].num_defs; i++) { @@ -1134,7 +1191,7 @@ qfo_to_progs (qfo_t *in_qfo, int *size) qfo->spaces[qfo_near_data_space].data_size * sizeof (pr_type_t)); qfo->spaces[qfo_near_data_space].data = globals; // clear locals data - memset (locals, 0, locals_size * sizeof (pr_type_t)); + memset (locals, 0, globals_info.locals_size * sizeof (pr_type_t)); // copy far data memcpy (far_data, qfo->spaces[qfo_far_data_space].data, qfo->spaces[qfo_far_data_space].data_size * sizeof (pr_type_t)); @@ -1148,30 +1205,30 @@ qfo_to_progs (qfo_t *in_qfo, int *size) if (types_def) { qfot_type_encodings_t *encodings; encodings = (qfot_type_encodings_t *) &globals[types_def->offset]; - encodings->types = type_encodings_start; + encodings->types = globals_info.type_encodings_start; encodings->size = qfo->spaces[qfo_type_space].data_size; } if (xdefs_def) { xdefs = (pr_xdefs_t *) &globals[xdefs_def->offset]; xdef = (xdef_t *) xdef_data; - xdefs->xdefs = xdefs_start; + xdefs->xdefs = globals_info.xdefs_start; xdefs->num_xdefs = progs->globaldefs.count + progs->fielddefs.count; for (i = 0; i < qfo->spaces[qfo_near_data_space].num_defs; i++, xdef++) { qfo_def_t *def = qfo->spaces[qfo_near_data_space].defs + i; - xdef->type = def->type + type_encodings_start; + xdef->type = def->type + globals_info.type_encodings_start; xdef->ofs = def->offset; } for (i = 0; i < qfo->spaces[qfo_far_data_space].num_defs; i++, xdef++) { qfo_def_t *def = qfo->spaces[qfo_far_data_space].defs + i; - xdef->type = def->type + type_encodings_start; + xdef->type = def->type + globals_info.type_encodings_start; xdef->ofs = def->offset; } for (i = 0; i < qfo->spaces[qfo_entity_space].num_defs; i++, xdef++) { qfo_def_t *def = qfo->spaces[qfo_entity_space].defs + i; - xdef->type = def->type + type_encodings_start; + xdef->type = def->type + globals_info.type_encodings_start; xdef->ofs = def->offset; } } @@ -1183,7 +1240,7 @@ qfo_to_progs (qfo_t *in_qfo, int *size) qfo_func_t *qf = qfo->funcs + i; qfo_mspace_t *space = qfo->spaces + qf->locals_space; - if (qf->locals_space == big_locals) + if (qf->locals_space == globals_info.big_locals) big_func = i; for (j = 0; j < space->num_defs; j++) space->defs[j].offset -= df->parm_start; @@ -1199,8 +1256,9 @@ qfo_to_progs (qfo_t *in_qfo, int *size) printf ("%6i global defs\n", progs->globaldefs.count); printf ("%6i field defs\n", progs->fielddefs.count); printf ("%6i globals\n", progs->globals.count); - printf (" %6i near globals\n", near_data_size); - printf (" %6i locals size%s\n", locals_size, big_function); + printf (" %6i near globals\n", globals_info.near_data_size); + printf (" %6i locals size%s\n", + globals_info.locals_size, big_function); printf (" %6i far globals\n", qfo->spaces[qfo_far_data_space].data_size); printf (" %6i type globals\n", From e9dff4ff9c21d4c543aa014291b99a70c8397c98 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 27 Jan 2022 10:21:48 +0900 Subject: [PATCH 233/360] [gamecode] Correct types and widths for bitnot bitnot is the only unary operator in the bitops group and thus needs special handling. --- libs/gamecode/opcodes.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index d8b9ed711..eda713a31 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -91,8 +91,8 @@ bitops_formats = { "mnemonic": "{op_bit[oo]}", "opname": "{op_bit[oo]}", "format": "{bit_fmt[oo]}", - "widths": "{ss+1}, {ss+1}, {ss+1}", - "types": "{bit_types[t]}, {bit_types[t]}, {bit_types[t]}", + "widths": "{ss+1}, { oo < 3 and ss+1 or 0}, {ss+1}", + "types": "{bit_types[t]}, {oo < 3 and bit_types[t] or 'ev_invalid'}, {bit_types[t]}", "args": { "op_bit": ["bitand", "bitor", "bitxor", "bitnot"], "bit_type": ["I", "L"], From 59ee72320105a41354d1b66b1a9bfb603760f382 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 27 Jan 2022 10:55:06 +0900 Subject: [PATCH 234/360] [gamecode] Rename parm to param That misspelling bothered me from the very beginning, I'd always have trouble getting the name right when trying to access one of those fields. --- include/QF/progs.h | 6 ++-- include/QF/progs/pr_comp.h | 8 ++--- libs/gamecode/pr_builtins.c | 6 ++-- libs/gamecode/pr_debug.c | 32 +++++++++---------- libs/gamecode/pr_exec.c | 55 ++++++++++++++++---------------- libs/gamecode/pr_load.c | 8 ++--- ruamoko/qwaq/builtins/debug.c | 4 +-- tools/qfcc/source/disassemble.c | 7 ++-- tools/qfcc/source/dump_globals.c | 17 +++++----- tools/qfcc/source/obj_file.c | 16 +++++----- tools/qfcc/source/qfcc.c | 4 +-- 11 files changed, 83 insertions(+), 80 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 78e9913c9..f8ef4abfd 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1254,12 +1254,12 @@ typedef struct { */ typedef struct { pr_int_t first_statement; - pr_int_t numparms; + pr_int_t numparams; union { struct { - dparmsize_t parm_size[PR_MAX_PARAMS]; + dparmsize_t param_size[PR_MAX_PARAMS]; dfunction_t *descriptor; - pr_uint_t parm_start; + pr_uint_t params_start; pr_uint_t locals; pr_uint_t profile; }; diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 4ae88e18e..d201bff87 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -513,16 +513,16 @@ typedef struct dparmsize_s { typedef struct dfunction_s { pr_int_t first_statement; // negative numbers are builtins - pr_uint_t parm_start; // beginning of locals data space - pr_uint_t locals; // total ints of parms + locals + pr_uint_t params_start; // beginning of locals data space + pr_uint_t locals; // total ints of params + locals pr_uint_t profile; // runtime pr_string_t name; // source function name pr_string_t file; // source file defined in - pr_int_t numparms; // -ve is varargs (1s comp of real count) - dparmsize_t parm_size[PR_MAX_PARAMS]; + pr_int_t numparams; // -ve is varargs (1s comp of real count) + dparmsize_t param_size[PR_MAX_PARAMS]; } dfunction_t; typedef union pr_type_u { diff --git a/libs/gamecode/pr_builtins.c b/libs/gamecode/pr_builtins.c index fcccb57a4..eaec8b148 100644 --- a/libs/gamecode/pr_builtins.c +++ b/libs/gamecode/pr_builtins.c @@ -196,10 +196,10 @@ PR_RelocateBuiltins (progs_t *pr) func = pr->function_table + i; func->first_statement = desc->first_statement; - func->parm_start = desc->parm_start; + func->params_start = desc->params_start; func->locals = desc->locals; - func->numparms = desc->numparms; - memcpy (func->parm_size, desc->parm_size, sizeof (func->parm_size)); + func->numparams = desc->numparams; + memcpy (func->param_size, desc->param_size, sizeof (func->param_size)); func->descriptor = desc; if (desc->first_statement > 0) diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 9eff304dd..b9832389a 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -914,7 +914,7 @@ PR_Get_Source_Line (progs_t *pr, pr_uint_t addr) } pr_def_t * -PR_Get_Param_Def (progs_t *pr, dfunction_t *func, unsigned parm) +PR_Get_Param_Def (progs_t *pr, dfunction_t *func, unsigned param) { prdeb_resources_t *res = pr->pr_debug_resources; pr_uint_t i; @@ -928,12 +928,12 @@ PR_Get_Param_Def (progs_t *pr, dfunction_t *func, unsigned parm) if (!func) return 0; - num_params = func->numparms; + num_params = func->numparams; if (num_params < 0) { num_params = ~num_params; // one's compliment param_offs = 1; // skip over @args def } - if (parm >= (unsigned) num_params) + if (param >= (unsigned) num_params) return 0; aux_func = res->auxfunction_map[func - pr->pr_functions]; @@ -942,7 +942,7 @@ PR_Get_Param_Def (progs_t *pr, dfunction_t *func, unsigned parm) for (i = 0; i < aux_func->num_locals; i++) { ddef = &res->local_defs[aux_func->local_defs + param_offs + i]; - if (!parm--) + if (!param--) break; } return ddef; @@ -987,7 +987,7 @@ PR_Get_Local_Def (progs_t *pr, pr_ptr_t *offset) aux_func = res->auxfunction_map[func - pr->pr_functions]; if (!aux_func) return 0; - offs -= func->parm_start; + offs -= func->params_start; if (offs >= func->locals) return 0; if ((def = PR_SearchDefs (res->local_defs + aux_func->local_defs, @@ -1531,7 +1531,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) const char *fmt; const char *mnemonic; dfunction_t *call_func = 0; - pr_def_t *parm_def = 0; + pr_def_t *param_def = 0; pr_auxfunction_t *aux_func = 0; pr_debug_data_t data; etype_t op_type[3]; @@ -1603,16 +1603,16 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) } else { const char *str; char mode = fmt[1], opchar = fmt[2]; - unsigned parm_ind = 0; + unsigned param_ind = 0; pr_uint_t opval; qfot_type_t *optype = &res->void_type; pr_func_t func; if (mode == 'P') { opchar = fmt[3]; - parm_ind = fmt[2] - '0'; + param_ind = fmt[2] - '0'; fmt++; // P has one extra item - if (parm_ind >= PR_MAX_PARAMS) + if (param_ind >= PR_MAX_PARAMS) goto err; } @@ -1631,7 +1631,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) break; case 'x': if (mode == 'P') { - opval = pr->pr_real_params[parm_ind] + opval = pr->pr_real_params[param_ind] - pr->pr_globals; break; } @@ -1657,10 +1657,10 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) } break; case 'P': - parm_def = PR_Get_Param_Def (pr, call_func, parm_ind); + param_def = PR_Get_Param_Def (pr, call_func, param_ind); optype = &res->void_type; - if (parm_def) { - optype = get_type (res, parm_def->type_encoding); + if (param_def) { + optype = get_type (res, param_def->type_encoding); } str = global_string (&data, opval, optype, contents & 1); @@ -1690,12 +1690,12 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) { edict_t *ed = 0; opval = pr->pr_globals[s->a].entity_var; - parm_ind = pr->pr_globals[s->b].uint_var; - if (parm_ind < pr->progs->entityfields + param_ind = pr->pr_globals[s->b].uint_var; + if (param_ind < pr->progs->entityfields && opval > 0 && opval < pr->pr_edict_area_size) { ed = PROG_TO_EDICT (pr, opval); - opval = &E_fld(ed, parm_ind) - pr->pr_globals; + opval = &E_fld(ed, param_ind) - pr->pr_globals; } if (!ed) { str = "bad entity.field"; diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 3c0734617..43bd1ff9b 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -193,9 +193,9 @@ PR_PopFrame (progs_t *pr) } static __attribute__((pure)) long -align_offset (long offset, dparmsize_t parmsize) +align_offset (long offset, dparmsize_t paramsize) { - int mask = (1 << parmsize.alignment) - 1; + int mask = (1 << paramsize.alignment) - 1; return (offset + mask) & ~mask; } @@ -237,39 +237,39 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) return; } - if (f->numparms > 0) { - paramofs = f->parm_start; - for (i = 0; i < f->numparms; i++) { - paramofs = align_offset (paramofs, f->parm_size[i]); + if (f->numparams > 0) { + paramofs = f->params_start; + for (i = 0; i < f->numparams; i++) { + paramofs = align_offset (paramofs, f->param_size[i]); dstParams[i] = pr->pr_globals + paramofs; - paramofs += f->parm_size[i].size; + paramofs += f->param_size[i].size; if (pr->pr_params[i] != pr->pr_real_params[i]) { copy_param (pr->pr_real_params[i], pr->pr_params[i], - f->parm_size[i].size); + f->param_size[i].size); pr->pr_params[i] = pr->pr_real_params[i]; } } - } else if (f->numparms < 0) { - paramofs = f->parm_start + 2; // argc and argv - for (i = 0; i < -f->numparms - 1; i++) { - paramofs = align_offset (paramofs, f->parm_size[i]); + } else if (f->numparams < 0) { + paramofs = f->params_start + 2; // argc and argv + for (i = 0; i < -f->numparams - 1; i++) { + paramofs = align_offset (paramofs, f->param_size[i]); dstParams[i] = pr->pr_globals + paramofs; - paramofs += f->parm_size[i].size; + paramofs += f->param_size[i].size; if (pr->pr_params[i] != pr->pr_real_params[i]) { copy_param (pr->pr_real_params[i], pr->pr_params[i], - f->parm_size[i].size); + f->param_size[i].size); pr->pr_params[i] = pr->pr_real_params[i]; } } - dparmsize_t parmsize = { pr->pr_param_size, pr->pr_param_alignment }; - paramofs = align_offset (paramofs, parmsize ); + dparmsize_t paramsize = { pr->pr_param_size, pr->pr_param_alignment }; + paramofs = align_offset (paramofs, paramsize ); if (i < PR_MAX_PARAMS) { dstParams[i] = pr->pr_globals + paramofs; } for (; i < pr->pr_argc; i++) { if (pr->pr_params[i] != pr->pr_real_params[i]) { copy_param (pr->pr_real_params[i], pr->pr_params[i], - parmsize.size); + paramsize.size); pr->pr_params[i] = pr->pr_real_params[i]; } } @@ -280,27 +280,28 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) PR_RunError (pr, "PR_EnterFunction: locals stack overflow"); memcpy (&pr->localstack[pr->localstack_used], - &pr->pr_globals[f->parm_start], + &pr->pr_globals[f->params_start], sizeof (pr_type_t) * f->locals); pr->localstack_used += f->locals; if (pr_deadbeef_locals->int_val) { - for (pr_uint_t i = f->parm_start; i < f->parm_start + f->locals; i++) { + for (pr_uint_t i = f->params_start; + i < f->params_start + f->locals; i++) { pr->pr_globals[i].int_var = 0xdeadbeef; } } // copy parameters - if (f->numparms >= 0) { - for (i = 0; i < f->numparms; i++) { - copy_param (dstParams[i], pr->pr_params[i], f->parm_size[i].size); + if (f->numparams >= 0) { + for (i = 0; i < f->numparams; i++) { + copy_param (dstParams[i], pr->pr_params[i], f->param_size[i].size); } } else { int copy_args; - pr_type_t *argc = &pr->pr_globals[f->parm_start + 0]; - pr_type_t *argv = &pr->pr_globals[f->parm_start + 1]; - for (i = 0; i < -f->numparms - 1; i++) { - copy_param (dstParams[i], pr->pr_params[i], f->parm_size[i].size); + pr_type_t *argc = &pr->pr_globals[f->params_start + 0]; + pr_type_t *argv = &pr->pr_globals[f->params_start + 1]; + for (i = 0; i < -f->numparams - 1; i++) { + copy_param (dstParams[i], pr->pr_params[i], f->param_size[i].size); } copy_args = pr->pr_argc - i; argc->int_var = copy_args; @@ -338,7 +339,7 @@ PR_LeaveFunction (progs_t *pr, int to_engine) if (pr->localstack_used < 0) PR_RunError (pr, "PR_LeaveFunction: locals stack underflow"); - memcpy (&pr->pr_globals[f->parm_start], + memcpy (&pr->pr_globals[f->params_start], &pr->localstack[pr->localstack_used], sizeof (pr_type_t) * f->locals); } diff --git a/libs/gamecode/pr_load.c b/libs/gamecode/pr_load.c index 165ca789b..1443d1a12 100644 --- a/libs/gamecode/pr_load.c +++ b/libs/gamecode/pr_load.c @@ -251,12 +251,12 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) for (i = 0; i < pr->progs->functions.count; i++) { pr->pr_functions[i].first_statement = LittleLong (pr->pr_functions[i].first_statement); - pr->pr_functions[i].parm_start = - LittleLong (pr->pr_functions[i].parm_start); + pr->pr_functions[i].params_start = + LittleLong (pr->pr_functions[i].params_start); pr->pr_functions[i].name = LittleLong (pr->pr_functions[i].name); pr->pr_functions[i].file = LittleLong (pr->pr_functions[i].file); - pr->pr_functions[i].numparms = - LittleLong (pr->pr_functions[i].numparms); + pr->pr_functions[i].numparams = + LittleLong (pr->pr_functions[i].numparams); pr->pr_functions[i].locals = LittleLong (pr->pr_functions[i].locals); if (pr->pr_functions[i].name) Hash_Add (pr->function_hash, &pr->pr_functions[i]); diff --git a/ruamoko/qwaq/builtins/debug.c b/ruamoko/qwaq/builtins/debug.c index 10c09c136..73eb5972f 100644 --- a/ruamoko/qwaq/builtins/debug.c +++ b/ruamoko/qwaq/builtins/debug.c @@ -522,12 +522,12 @@ return_function (progs_t *pr, dfunction_t *func) __auto_type f = (qdb_function_t *) PR_Zone_Malloc (pr, sizeof (qdb_function_t)); f->staddr = func->first_statement; - f->local_data = func->parm_start; + f->local_data = func->params_start; f->local_size = func->locals; f->profile = func->profile; f->name = func->name; f->file = func->file; - f->num_params = func->numparms; + f->num_params = func->numparams; R_POINTER (pr) = PR_SetPointer (pr, f); } } diff --git a/tools/qfcc/source/disassemble.c b/tools/qfcc/source/disassemble.c index 953ab8143..5b8ec9735 100644 --- a/tools/qfcc/source/disassemble.c +++ b/tools/qfcc/source/disassemble.c @@ -70,10 +70,11 @@ disassemble_progs (progs_t *pr) bfunction_t func; func.first_statement = desc->first_statement; - func.parm_start = desc->parm_start; + func.params_start = desc->params_start; func.locals = desc->locals; - func.numparms = desc->numparms; - memcpy (func.parm_size, desc->parm_size, sizeof (func.parm_size)); + func.numparams = desc->numparams; + memcpy (func.param_size, desc->param_size, + sizeof (func.param_size)); func.descriptor = desc; Sys_Printf ("%s:\n", PR_GetString (pr, desc->name)); diff --git a/tools/qfcc/source/dump_globals.c b/tools/qfcc/source/dump_globals.c index 256c5e9d6..3f1b412cd 100644 --- a/tools/qfcc/source/dump_globals.c +++ b/tools/qfcc/source/dump_globals.c @@ -259,15 +259,15 @@ dump_functions (progs_t *pr) else comment = va (0, " = #%d", -start); - printf ("%-5d %s%s: %d (", i, name, comment, func->numparms); - if (func->numparms < 0) - count = -func->numparms - 1; + printf ("%-5d %s%s: %d (", i, name, comment, func->numparams); + if (func->numparams < 0) + count = -func->numparams - 1; else - count = func->numparms; + count = func->numparams; for (j = 0; j < count; j++) - printf (" %d:%d", func->parm_size[j].alignment, - func->parm_size[j].size); - printf (") %d @ %x", func->locals, func->parm_start); + printf (" %d:%d", func->param_size[j].alignment, + func->param_size[j].size); + printf (") %d @ %x", func->locals, func->params_start); puts (""); if (type_encodings) { pr_auxfunction_t *aux = PR_Debug_MappedAuxFunction (pr, i); @@ -476,7 +476,8 @@ qfo_functions (qfo_t *qfo) printf (" @ %x", func->code); else printf (" = #%d", -func->code); - printf (" loc: %d\n", func->locals_space); + printf (" loc: %d params: %d\n", + func->locals_space, func->params_start); if (func->locals_space) { locals = &qfo->spaces[func->locals_space]; printf ("%*s%d %p %d %p %d %d\n", 16, "", locals->type, diff --git a/tools/qfcc/source/obj_file.c b/tools/qfcc/source/obj_file.c index a672a41fa..8f3dac1d6 100644 --- a/tools/qfcc/source/obj_file.c +++ b/tools/qfcc/source/obj_file.c @@ -791,13 +791,13 @@ get_type_alignment_log (qfo_t *qfo, pr_ptr_t type) } static __attribute__((pure)) dparmsize_t -get_parmsize (qfo_t *qfo, pr_ptr_t type) +get_paramsize (qfo_t *qfo, pr_ptr_t type) { - dparmsize_t parmsize = { + dparmsize_t paramsize = { get_type_size (qfo, type), get_type_alignment_log (qfo, type), }; - return parmsize; + return paramsize; } static void @@ -816,11 +816,11 @@ function_params (qfo_t *qfo, qfo_func_t *func, dfunction_t *df) } if (type->meta != ty_basic || type->type != ev_func) return; - df->numparms = num_params = type->func.num_params; + df->numparams = num_params = type->func.num_params; if (num_params < 0) num_params = ~num_params; for (i = 0; i < num_params; i++) { - df->parm_size[i] = get_parmsize (qfo, type->func.param_types[i]); + df->param_size[i] = get_paramsize (qfo, type->func.param_types[i]); } } @@ -1140,9 +1140,9 @@ qfo_to_progs (qfo_t *in_qfo, int *size) qfo_mspace_t *space = qfo->spaces + qf->locals_space; df->first_statement = qf->code; + df->locals = space->data_size; if (options.code.progsversion < PROG_VERSION) { - df->parm_start = globals_info.locals_start; - df->locals = space->data_size; + df->params_start = globals_info.locals_start; // finalize the offsets of the local defs for (j = 0; j < space->num_defs; j++) space->defs[j].offset += globals_info.locals_start; @@ -1243,7 +1243,7 @@ qfo_to_progs (qfo_t *in_qfo, int *size) if (qf->locals_space == globals_info.big_locals) big_func = i; for (j = 0; j < space->num_defs; j++) - space->defs[j].offset -= df->parm_start; + space->defs[j].offset -= df->params_start; } if (options.verbosity >= 0) { diff --git a/tools/qfcc/source/qfcc.c b/tools/qfcc/source/qfcc.c index ae256c8cf..5cc8c7aa4 100644 --- a/tools/qfcc/source/qfcc.c +++ b/tools/qfcc/source/qfcc.c @@ -228,12 +228,12 @@ WriteProgs (dprograms_t *progs, int size) for (i = 0; i < (unsigned) progs->functions.count; i++) { dfunction_t *func = functions + i; func->first_statement = LittleLong (func->first_statement); - func->parm_start = LittleLong (func->parm_start); + func->params_start = LittleLong (func->params_start); func->locals = LittleLong (func->locals); func->profile = LittleLong (func->profile); func->name = LittleLong (func->name); func->file = LittleLong (func->file); - func->numparms = LittleLong (func->numparms); + func->numparams = LittleLong (func->numparams); } for (i = 0; i < progs->globaldefs.count; i++) { globaldefs[i].type = LittleShort (globaldefs[i].type); From a0d9cf8d8e67097b1fd2967b68df3a1a35fa2e21 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 27 Jan 2022 10:56:57 +0900 Subject: [PATCH 235/360] [gamecode] Improve verbose statement prints for Ruamoko They now include base register index and effective address of the operands (though it may be wrong for instructions that don't use a base register for that operand). --- libs/gamecode/pr_debug.c | 38 ++++++++++++++++++++++++++++++++------ 1 file changed, 32 insertions(+), 6 deletions(-) diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index b9832389a..f53f13ba6 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -54,6 +54,7 @@ #include "QF/quakefs.h" #include "QF/script.h" #include "QF/sys.h" +#include "QF/va.h" #include "QF/zone.h" #include "QF/progs/pr_debug.h" @@ -91,6 +92,7 @@ typedef struct prdeb_resources_s { dstring_t *dva; dstring_t *line; dstring_t *dstr; + va_ctx_t *va; const char *debugfile; pr_debug_header_t *debug; pr_auxfunction_t *auxfunctions; @@ -1522,6 +1524,18 @@ PR_Debug_Print (progs_t *pr, const char *expr) } } +static const char * +print_raw_op (progs_t *pr, pr_ushort_t op, pr_ushort_t base_ind, + etype_t op_type, int op_width) +{ + prdeb_resources_t *res = pr->pr_debug_resources; + const char *width = va (res->va, "%d", op_width); + return va (res->va, "%d:%04x<%08x>%s:%-8s", + base_ind, op, op + pr->pr_bases[base_ind], + op_width > 0 ? width : op_width < 0 ? "X" : "?", + pr_type_name[op_type]); +} + VISIBLE void PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) { @@ -1585,12 +1599,23 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) dasprintf (res->line, "%04x ", addr); if (pr_debug->int_val > 2) { - dasprintf (res->line, - "%03x %04x(%8s)[%d] %04x(%8s)[%d] %04x(%8s)[%d]\t", - s->op, - s->a, pr_type_name[op_type[0]], op_width[0], - s->b, pr_type_name[op_type[1]], op_width[1], - s->c, pr_type_name[op_type[2]], op_width[2]); + if (pr->progs->version < PROG_VERSION) { + dasprintf (res->line, + "%03x %04x(%8s) %04x(%8s) %04x(%8s)\t", + s->op, + s->a, pr_type_name[op_type[0]], + s->b, pr_type_name[op_type[1]], + s->c, pr_type_name[op_type[2]]); + } else { + dasprintf (res->line, "%04x %s %s %s\t", + s->op, + print_raw_op (pr, s->a, PR_BASE_IND (s->op, A), + op_type[0], op_width[0]), + print_raw_op (pr, s->b, PR_BASE_IND (s->op, B), + op_type[0], op_width[0]), + print_raw_op (pr, s->c, PR_BASE_IND (s->op, C), + op_type[0], op_width[0])); + } } dasprintf (res->line, "%s ", mnemonic); @@ -1895,6 +1920,7 @@ PR_Debug_Init (progs_t *pr) res->dva = dstring_newstr (); res->line = dstring_newstr (); res->dstr = dstring_newstr (); + res->va = va_create_context (8); res->void_type.meta = ty_basic; res->void_type.size = 4; From 42db8514ae1e6513a165be129c7ea9230adebb2f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 27 Jan 2022 11:24:00 +0900 Subject: [PATCH 236/360] [gamecode] Use version instead of locals count It turned out I need locals count and params_start for debugging, so use the progs version instead to bail early from PR_EnterFunction and PR_LeaveFunction (which I had forgotten anyway, oops). --- libs/gamecode/pr_exec.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 43bd1ff9b..9801d9936 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -233,7 +233,7 @@ PR_EnterFunction (progs_t *pr, bfunction_t *f) pr->pr_xfunction = f; pr->pr_xstatement = f->first_statement - 1; // offset the st++ - if (!f->locals) { + if (pr->progs->version == PROG_VERSION) { return; } @@ -334,6 +334,10 @@ PR_LeaveFunction (progs_t *pr, int to_engine) } } + if (pr->progs->version == PROG_VERSION) { + return; + } + // restore locals from the stack pr->localstack_used -= f->locals; if (pr->localstack_used < 0) From 0123e123042da39b4097db624128319cd8f353fe Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 27 Jan 2022 11:25:50 +0900 Subject: [PATCH 237/360] [qfcc] Use locals and params_start to describe stack frame This is necessary to get statement disassembly working, and likely debugging in general. locals is the total size of the stack frame and thus reaches above the function-entry stack pointer, and params_start is the local space relative start of the parameters. Thus, knowing the function-entry stack pointer, the bottom of the locals space can be found by subtracting params_start, and the top of the locals space by adding (locals - params_start). --- tools/qfcc/include/function.h | 2 +- tools/qfcc/include/obj_file.h | 4 +++- tools/qfcc/source/function.c | 12 +++++++++--- tools/qfcc/source/obj_file.c | 5 +++++ 4 files changed, 18 insertions(+), 5 deletions(-) diff --git a/tools/qfcc/include/function.h b/tools/qfcc/include/function.h index cceef9341..3a089a4c2 100644 --- a/tools/qfcc/include/function.h +++ b/tools/qfcc/include/function.h @@ -65,7 +65,7 @@ typedef struct function_s { int code; ///< first statement int function_num; int line_info; - int local_defs; + int params_start;///< relative to locals space. 0 for v6p pr_string_t s_file; ///< source file with definition pr_string_t s_name; ///< name of function in output const struct type_s *type; ///< function's type without aliases diff --git a/tools/qfcc/include/obj_file.h b/tools/qfcc/include/obj_file.h index b827d58a1..e93c3013a 100644 --- a/tools/qfcc/include/obj_file.h +++ b/tools/qfcc/include/obj_file.h @@ -211,7 +211,9 @@ typedef struct qfo_func_s { pr_uint_t relocs; ///< Index to first ::qfo_reloc_t reloc record. pr_uint_t num_relocs; ///< Number of reloc records. //@} - pr_int_t reserved[2]; + pr_uint_t params_start; ///< locals_space relative start of parameters + ///< always 0 for v6/v6p progs + pr_int_t reserved; } qfo_func_t; /** Evil source of many headaches. The whole reason I've started writing this diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index d094fc152..97481dee8 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -773,6 +773,8 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements) // first defspace_t *space = defspace_new (ds_virtual); + func->params_start = 0; + merge_spaces (space, func->parameters->space, 1); func->parameters->space = space; @@ -790,15 +792,19 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements) merge_spaces (space, func->locals->space, 4); func->locals->space = space; - // allocate 0 words to force alignment - defspace_alloc_aligned_highwater (space, 0, 4); + // allocate 0 words to force alignment and get the address + func->params_start = defspace_alloc_aligned_highwater (space, 0, 4); dstatement_t *st = &pr.code->code[func->code]; if (st->op == OP_ADJSTK) { - st->b = -space->size; + st->b = -func->params_start; } merge_spaces (space, func->parameters->space, 4); func->parameters->space = space; + + // force the alignment again so the full stack slot is counted when + // the final parameter is smaller than 4 words + defspace_alloc_aligned_highwater (space, 0, 4); } return fsym->s.func; } diff --git a/tools/qfcc/source/obj_file.c b/tools/qfcc/source/obj_file.c index 8f3dac1d6..ce84d06c3 100644 --- a/tools/qfcc/source/obj_file.c +++ b/tools/qfcc/source/obj_file.c @@ -314,6 +314,7 @@ qfo_encode_functions (qfo_t *qfo, qfo_def_t **defs, qfo_reloc_t **relocs, q->line_info = f->line_info; q->relocs = *relocs - qfo->relocs; q->num_relocs = qfo_encode_relocs (f->refs, relocs, q - qfo->funcs); + q->params_start = f->params_start; } } @@ -530,6 +531,7 @@ qfo_write (qfo_t *qfo, const char *filename) funcs[i].line_info = LittleLong (qfo->funcs[i].line_info); funcs[i].relocs = LittleLong (qfo->funcs[i].relocs); funcs[i].num_relocs = LittleLong (qfo->funcs[i].num_relocs); + funcs[i].params_start = LittleLong (qfo->funcs[i].params_start); } for (i = 0; i < qfo->num_lines; i++) { lines[i].fa.addr = LittleLong (qfo->lines[i].fa.addr); @@ -1148,6 +1150,9 @@ qfo_to_progs (qfo_t *in_qfo, int *size) space->defs[j].offset += globals_info.locals_start; if (!options.code.local_merging) globals_info.locals_start += align_globals_size (df->locals); + } else { + // relative to start of locals for Ruamoko progs + df->params_start = qf->params_start; } df->profile = 0; df->name = qf->name; From 4b4cb60c65596c32707fc8303bf072c1e44d2226 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 27 Jan 2022 11:42:23 +0900 Subject: [PATCH 238/360] [qfcc] Check qfo target matches compile target Linking mixed target VMs is unlikely to end well. --- tools/qfcc/source/obj_file.c | 7 +++++++ tools/qfcc/test/Makemodule.am | 2 +- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/obj_file.c b/tools/qfcc/source/obj_file.c index ce84d06c3..3d5f064c3 100644 --- a/tools/qfcc/source/obj_file.c +++ b/tools/qfcc/source/obj_file.c @@ -573,6 +573,13 @@ qfo_read (QFile *file) free (data); return 0; } + // qfprogs leaves progsversion as 0 + if (options.code.progsversion + && header->progs_version != options.code.progsversion) { + fprintf (stderr, "qfo file target VM does not match current target\n"); + free (data); + return 0; + } qfo = calloc (1, sizeof (qfo_t)); qfo->num_spaces = LittleLong (header->num_spaces); diff --git a/tools/qfcc/test/Makemodule.am b/tools/qfcc/test/Makemodule.am index 88b9e8480..f555e89f1 100644 --- a/tools/qfcc/test/Makemodule.am +++ b/tools/qfcc/test/Makemodule.am @@ -169,7 +169,7 @@ tools_qfcc_test_chewed_return_dat_SOURCES=tools/qfcc/test/chewed-return.r chewed_return_obj=$(tools_qfcc_test_chewed_return_dat_SOURCES:.r=.o) chewed_return_dep=$(call qcautodep,$(tools_qfcc_test_chewed_return_dat_SOURCES)) tools/qfcc/test/chewed-return.dat$(EXEEXT): $(chewed_return_obj) $(QFCC_DEP) - $(V_QFCCLD)$(QLINK) -o $@ $(chewed_return_obj) + $(V_QFCCLD)$(QLINK) -Ctarget=v6 -o $@ $(chewed_return_obj) tools/qfcc/test/chewed-return.run: $(qfcc_test_run_deps) @TEST_HARNESS_OPTS=--float $(top_srcdir)/tools/qfcc/test/build-run $@ include $(chewed_return_dep) # am--include-marker From de974fdd3f9cfb527753c18528b7289e0d73092d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 27 Jan 2022 13:29:38 +0900 Subject: [PATCH 239/360] [gamecode] Add format for addressing modes and use in return This fixes Ruamoko's return format string. It looks like it's producing the correct address (but doesn't show all the information it should), but the rest of the debug code needs work locals. --- libs/gamecode/opcodes.py | 2 +- libs/gamecode/pr_debug.c | 38 +++++++++++++++++++++++++++++++++++ libs/gamecode/pr_v6p_opcode.c | 9 +++++++++ 3 files changed, 48 insertions(+), 1 deletion(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index eda713a31..a7fc99a22 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -463,7 +463,7 @@ return_formats = { "mnemonic": "return", "opname": "return", "widths": "-1, -1, 0", # width specified by st->c - "format": "FIXME", + "format": "%Mc5", "types": "ev_void, ev_void, ev_void", } vecops_formats = { diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index f53f13ba6..ea854efcf 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -1629,6 +1629,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) const char *str; char mode = fmt[1], opchar = fmt[2]; unsigned param_ind = 0; + pr_uint_t shift = 0; pr_uint_t opval; qfot_type_t *optype = &res->void_type; pr_func_t func; @@ -1640,6 +1641,15 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) if (param_ind >= PR_MAX_PARAMS) goto err; } + if (mode == 'M' || mode == 'm') { + if (!isxdigit (fmt[3])) { + goto err; + } + shift = fmt[3]; + shift = (shift & 0xf) + + (((shift & 0x40) >> 3) | ((shift & 0x40) >> 5)); + fmt++; // M/m have one extra item + } switch (opchar) { case 'a': @@ -1732,6 +1742,34 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) s->a, s->b, str); } break; + case 'M': + case 'm': + { + pr_ptr_t ptr = 0; + pr_int_t offs = 0; + switch ((opval >> shift) & 3) { + case 0: + ptr = s->a + PR_BASE (pr, s, A); + break; + case 1: + break; + case 2: + ptr = s->a + PR_BASE (pr, s, A); + ptr = G_POINTER (pr, ptr); + offs = (short) s->b; + break; + case 3: + ptr = s->a + PR_BASE (pr, s, A); + ptr = G_POINTER (pr, ptr); + offs = s->b + PR_BASE (pr, s, B); + offs = G_INT (pr, offs); + break; + } + ptr += offs; + str = global_string (&data, ptr, optype, + mode == 'M'); + } + break; default: goto err; } diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index 13f129553..cb11c9eca 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -54,10 +54,19 @@ // F function (must come before any P) // R return value // E entity + field (%Eab) +// M addressing mode, contents +// m addressing mode, no contents +// takes operand (a,b,c,o (opcode)) and right shift(hex). always masked +// by 3 +// %Mc5 -> contents, operand c, shift right 5 bits +// %mo2 -> no contents, opcode, shift right 2 bits +// %mo0 -> no contents, opcode, no shift +// always uses a and b for the address calculation (Ruamoko convention)) // // a operand a // b operand b // c operand c +// o opcode // x place holder for P (padding) // 0-7 parameter index (for P) VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { From 5c222530956eb3a0e9b4e8a63b4f259cfd0460ba Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 27 Jan 2022 14:16:05 +0900 Subject: [PATCH 240/360] [gamecode] Use the stack frame to find local defs Of course, only in Ruamoko progs, but it works quite nicely. global_string is now passed the absolute address of the referenced operand. With a little groveling through the progs stack, it should be possible to resolve pointers to locals in functions further up the stack. --- libs/gamecode/pr_debug.c | 32 ++++++++++++++++++++++++++++---- 1 file changed, 28 insertions(+), 4 deletions(-) diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index ea854efcf..b9c3862c5 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -989,7 +989,19 @@ PR_Get_Local_Def (progs_t *pr, pr_ptr_t *offset) aux_func = res->auxfunction_map[func - pr->pr_functions]; if (!aux_func) return 0; - offs -= func->params_start; + + pr_ptr_t locals_start; + if (pr->progs->version == PROG_VERSION) { + if (pr->pr_depth) { + prstack_t *frame = pr->pr_stack + pr->pr_depth - 1; + locals_start = frame->stack_ptr - func->params_start; + } else { + locals_start = 0; //FIXME ? when disassembling in qfprogs + } + } else { + locals_start = func->params_start; + } + offs -= locals_start; if (offs >= func->locals) return 0; if ((def = PR_SearchDefs (res->local_defs + aux_func->local_defs, @@ -1115,12 +1127,12 @@ pr_debug_find_def (progs_t *pr, pr_ptr_t *ofs) prdeb_resources_t *res = pr->pr_debug_resources; pr_def_t *def = 0; - if (*ofs >= pr->progs->globals.count) { - return 0; - } if (pr_debug->int_val && res->debug) { def = PR_Get_Local_Def (pr, ofs); } + if (*ofs >= pr->progs->globals.count) { + return 0; + } if (!def) { def = PR_GlobalAtOfs (pr, *ofs); if (def) { @@ -1630,6 +1642,7 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) char mode = fmt[1], opchar = fmt[2]; unsigned param_ind = 0; pr_uint_t shift = 0; + pr_uint_t opreg; pr_uint_t opval; qfot_type_t *optype = &res->void_type; pr_func_t func; @@ -1653,23 +1666,31 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) switch (opchar) { case 'a': + opreg = PR_BASE_IND (s->op, A); opval = s->a; optype = res->type_encodings[op_type[0]]; break; case 'b': + opreg = PR_BASE_IND (s->op, B); opval = s->b; optype = res->type_encodings[op_type[1]]; break; case 'c': + opreg = PR_BASE_IND (s->op, C); opval = s->c; optype = res->type_encodings[op_type[2]]; break; + case 'o': + opreg = 0; + opval = s->op; + break; case 'x': if (mode == 'P') { opval = pr->pr_real_params[param_ind] - pr->pr_globals; break; } + goto err; default: goto err; } @@ -1701,14 +1722,17 @@ PR_PrintStatement (progs_t *pr, dstatement_t *s, int contents) contents & 1); break; case 'V': + opval += pr->pr_bases[opreg]; str = global_string (&data, opval, ev_void, contents & 1); break; case 'G': + opval += pr->pr_bases[opreg]; str = global_string (&data, opval, optype, contents & 1); break; case 'g': + opval += pr->pr_bases[opreg]; str = global_string (&data, opval, optype, 0); break; case 's': From 82166406df9ad196fb598fe83d76f0f338b03f9d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 27 Jan 2022 16:43:43 +0900 Subject: [PATCH 241/360] [qfcc] Remove the def sorting (reverts 9a08a51ebd) It turns out the sorting wasn't working properly and I've decided that anything that actually needs the defs to be sorted by address (such as a debugger searching for defs by address) can do the sorting itself. Fixes a weird swapping of def names. --- tools/qfcc/source/obj_file.c | 50 +++--------------------------------- 1 file changed, 4 insertions(+), 46 deletions(-) diff --git a/tools/qfcc/source/obj_file.c b/tools/qfcc/source/obj_file.c index 3d5f064c3..d7144ae27 100644 --- a/tools/qfcc/source/obj_file.c +++ b/tools/qfcc/source/obj_file.c @@ -31,8 +31,6 @@ # include "config.h" #endif -#define _GNU_SOURCE // for qsort_r - #ifdef HAVE_STRING_H # include #endif @@ -926,17 +924,6 @@ align_globals_size (unsigned size) return RUP (size, 16 / sizeof (pr_type_t)); } -static int -qfo_def_offset_compare (const void *i1, const void *i2, void *d) -{ - __auto_type defs = (const qfo_def_t *) d; - unsigned ind1 = *(unsigned *) i1; - unsigned ind2 = *(unsigned *) i2; - const qfo_def_t *def1 = defs + ind1; - const qfo_def_t *def2 = defs + ind2; - return def1->offset - def2->offset; -} - static pr_uint_t qfo_count_locals (const qfo_t *qfo, pr_uint_t *big_locals) { @@ -1027,9 +1014,6 @@ qfo_to_progs (qfo_t *in_qfo, int *size) int big_func = 0; pr_xdefs_t *xdefs = 0; xdef_t *xdef; - unsigned *def_indices; - unsigned *far_def_indices; - unsigned *field_def_indices; // id progs were aligned to only 4 bytes, but 8 is much more reasonable pr_uint_t byte_align = 8; @@ -1099,29 +1083,6 @@ qfo_to_progs (qfo_t *in_qfo, int *size) progs = realloc (progs, *size); memset (progs + 1, 0, *size - sizeof (dprograms_t)); - def_indices = alloca ((progs->globaldefs.count + progs->fielddefs.count) - * sizeof (*def_indices)); - far_def_indices = def_indices + qfo->spaces[qfo_near_data_space].num_defs; - field_def_indices = def_indices + progs->globaldefs.count; - for (unsigned i = 0; i < qfo->spaces[qfo_near_data_space].num_defs; i++) { - def_indices[i] = i; - } - for (unsigned i = 0; i < qfo->spaces[qfo_far_data_space].num_defs; i++) { - far_def_indices[i] = i; - } - for (unsigned i = 0; i < qfo->spaces[qfo_entity_space].num_defs; i++) { - field_def_indices[i] = i; - } - qsort_r (def_indices, qfo->spaces[qfo_near_data_space].num_defs, - sizeof (unsigned), qfo_def_offset_compare, - qfo->spaces[qfo_near_data_space].defs); - qsort_r (far_def_indices, qfo->spaces[qfo_far_data_space].num_defs, - sizeof (unsigned), qfo_def_offset_compare, - qfo->spaces[qfo_far_data_space].defs); - qsort_r (field_def_indices, qfo->spaces[qfo_entity_space].num_defs, - sizeof (unsigned), qfo_def_offset_compare, - qfo->spaces[qfo_entity_space].defs); - #define qfo_block(t,b) (t *) ((byte *) progs + progs->b.offset) strings = qfo_block (char, strings); statements = qfo_block (dstatement_t, statements); @@ -1168,8 +1129,7 @@ qfo_to_progs (qfo_t *in_qfo, int *size) } for (i = 0; i < qfo->spaces[qfo_near_data_space].num_defs; i++) { - unsigned ind = def_indices[i]; - qfo_def_t *def = qfo->spaces[qfo_near_data_space].defs + ind; + qfo_def_t *def = qfo->spaces[qfo_near_data_space].defs + i; const char *defname = QFO_GETSTR (qfo, def->name); if (!strcmp (defname, ".type_encodings")) types_def = def; @@ -1179,8 +1139,7 @@ qfo_to_progs (qfo_t *in_qfo, int *size) } for (i = 0; i < qfo->spaces[qfo_far_data_space].num_defs; i++) { - unsigned ind = far_def_indices[i]; - qfo_def_t *def = qfo->spaces[qfo_far_data_space].defs + ind; + qfo_def_t *def = qfo->spaces[qfo_far_data_space].defs + i; def->offset += far_data - globals; qfo_def_to_ddef (qfo, def, globaldefs); // the correct offset will be written to the far data space @@ -1193,9 +1152,8 @@ qfo_to_progs (qfo_t *in_qfo, int *size) } for (i = 0; i < qfo->spaces[qfo_entity_space].num_defs; i++) { - unsigned ind = field_def_indices[i]; - qfo_def_to_ddef (qfo, qfo->spaces[qfo_entity_space].defs + ind, - fielddefs + i); + qfo_def_to_ddef (qfo, qfo->spaces[qfo_entity_space].defs + i, + fielddefs + i); } // copy near data From f57aa82c4b8fce295abd20c972e288c390bd8bf8 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 27 Jan 2022 23:24:43 +0900 Subject: [PATCH 242/360] [qfcc] Use an alias op for return_operand This is what using new_ret_expr would result in, but new_ret_expr is no longer used for referencing .return (except in pascal, but I haven't gotten around to sorting that out) due to the recent changes for Ruamoko progs. Fixes an ICE when compiling (with optimization) something like the following (dir is a vector): dir /= sqrt (dir * dir); return dir * speed; --- tools/qfcc/source/statements.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index e0ef25160..88763e01d 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -452,7 +452,11 @@ return_operand (type_t *type, expr_t *expr) symbol_t *return_symbol; return_symbol = make_symbol (".return", &type_param, pr.symtab->space, sc_extern); - return def_operand (return_symbol->s.def, type, expr); + if (!return_symbol->table) { + symtab_addsymbol (pr.symtab, return_symbol); + } + def_t *return_def = return_symbol->s.def; + return def_operand (alias_def (return_def, type, 0), 0, expr); } operand_t * From 7877168e93d1736e3fb0fffcca538d82add6320b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 27 Jan 2022 23:29:32 +0900 Subject: [PATCH 243/360] [qfcc] Make a field name more clear Just "type" isn't very informative, but "result_type" is at least a fair bit better. --- tools/qfcc/source/expr_binary.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index 22d4b8a5a..06fdb6668 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -40,7 +40,7 @@ typedef struct { int op; - type_t *type; + type_t *result_type; type_t *a_cast; type_t *b_cast; expr_t *(*process)(int op, expr_t *e1, expr_t *e2); @@ -952,7 +952,7 @@ binary_expr (int op, expr_t *e1, expr_t *e2) return fold_constants (e); e = new_binary_expr (op, e1, e2); - e->e.expr.type = expr_type->type; + e->e.expr.type = expr_type->result_type; if (is_compare (op) || is_logic (op)) { if (options.code.progsversion == PROG_ID_VERSION) { e->e.expr.type = &type_float; From 8d873a891f6251e84bb51e5459a060d8701c9be0 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 28 Jan 2022 09:17:10 +0900 Subject: [PATCH 244/360] [qfcc] Make struct ptr access consistent with class ivar access While this does make the generated code a little worse, load is behaving nicely), the two are at least consistent with each other and when I fix one, I'll fix both. I missed this change the other day when I did the address_expr cleanup. Yay near-duplicate code :P --- tools/qfcc/source/expr.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 497de95c6..54ac5780c 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1517,10 +1517,10 @@ field_expr (expr_t *e1, expr_t *e2) if (!field) return e1; - e2->type = ex_value; - e2->e.value = new_short_val (field->s.offset); - e = new_address_expr (field->type, e1, e2); - return unary_expr ('.', e); + expr_t *offset = new_short_expr (field->s.offset); + e1 = offset_pointer_expr (e1, offset); + e1 = cast_expr (pointer_type (field->type), e1); + return unary_expr ('.', e1); } else if (is_class (t1->t.fldptr.type)) { class_t *class = t1->t.fldptr.type->t.class; symbol_t *sym = e2->e.symbol;//FIXME need to check From ec9fa3fee84000d8bc65e5a0689ee83b358e60b5 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 28 Jan 2022 15:26:47 +0900 Subject: [PATCH 245/360] [qfcc] Clean up an unnecessary use of array_expr Simply dereferencing a pointer does not need to go through array_expr and thus collect a 0 offset that will only be constant-folded out again. Really just a minor optimization in qfcc, but at one stage in today's modification, it resulted in some unwanted aliasing chains. --- tools/qfcc/source/expr.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 54ac5780c..742a8d26d 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -2549,7 +2549,7 @@ deref_pointer_expr (expr_t *pointer) return pointer; if (pointer_type->type != ev_ptr) return error (pointer, "not a pointer"); - return array_expr (pointer, new_int_expr (0)); + return unary_expr ('.', pointer); } expr_t * From d28507eacf194ace90874e514c5342063487827c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 28 Jan 2022 15:29:40 +0900 Subject: [PATCH 246/360] [qfcc] Reduce some alias chaining Aliasing an alias expression to the same type as the original aliased expression is a no-op, so drop the alias entirely in order to simplify code generation. --- tools/qfcc/source/expr.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 742a8d26d..c9e36c7b2 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1309,6 +1309,12 @@ new_alias_expr (type_t *type, expr_t *expr) } expr = expr->e.alias.expr; } + // this can happen when constant folding an offset pointer results in + // a noop due to the offset being 0 and thus casting back to the original + // type + if (type == get_type (expr)) { + return expr; + } expr_t *alias = new_expr (); alias->type = ex_alias; From e298f0d993a889d7f3c0e56dadcffbfe1670674e Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 28 Jan 2022 15:37:08 +0900 Subject: [PATCH 247/360] [qfcc] Break out pointer addressing This allows the code handling simple pointer dereferences to recurse along an alias chain that resulted from casting between different pointer types (such chains could probably be eliminated by replacing the type in the original pointer expression, but it wasn't worth it at this stage). --- tools/qfcc/source/statements.c | 96 +++++++++++++++++++--------------- 1 file changed, 54 insertions(+), 42 deletions(-) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 88763e01d..91afd76d5 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1256,6 +1256,58 @@ statement_branch (sblock_t *sblock, expr_t *e) return sblock->next; } +static sblock_t * +ptr_addressing_mode (sblock_t *sblock, expr_t *ref, + operand_t **base, operand_t **offset, pr_ushort_t *mode) +{ + if (!is_ptr (get_type (ref))) { + internal_error (ref, "expected pointer in ref"); + } + if (ref->type != ex_alias || ref->e.alias.offset) { + // probably just a pointer + sblock = statement_subexpr (sblock, ref, base); + *offset = short_operand (0, ref); + *mode = 2; // mode C: ptr + constant index + } else if (is_ptr (get_type (ref->e.alias.expr))) { + // cast of one pointer type to another + return ptr_addressing_mode (sblock, ref->e.alias.expr, base, offset, + mode); + } else { + // alias with no offset + if (!is_integral (get_type (ref->e.alias.expr))) { + internal_error (ref, "expected integer expr in ref"); + } + expr_t *intptr = ref->e.alias.expr; + if (intptr->type != ex_expr + || (intptr->e.expr.op != '+' + && intptr->e.expr.op != '-')) { + // treat ref as simple pointer + sblock = statement_subexpr (sblock, ref, base); + *offset = short_operand (0, ref); + *mode = 2; // mode C: ptr + constant index + } else { + expr_t *ptr = intptr->e.expr.e1; + expr_t *offs = intptr->e.expr.e2; + int const_offs; + // move the +/- to the offset + offs = unary_expr (intptr->e.expr.op, offs); + // make the base a pointer again + ptr = new_alias_expr (ref->e.alias.type, ptr); + sblock = statement_subexpr (sblock, ptr, base); + if (is_constant (offs) + && (const_offs = expr_int (offs)) < 32768 + && const_offs >= -32768) { + *mode = 2; + *offset = short_operand (const_offs, ref); + } else { + *mode = 3; + sblock = statement_subexpr (sblock, offs, offset); + } + } + } + return sblock; +} + static sblock_t * addressing_mode (sblock_t *sblock, expr_t *ref, operand_t **base, operand_t **offset, pr_ushort_t *mode) @@ -1266,48 +1318,8 @@ addressing_mode (sblock_t *sblock, expr_t *ref, if (ref->type == ex_expr) { internal_error (ref, "not implemented"); } else if (ref->type == ex_uexpr) { - ref = ref->e.expr.e1; - if (!is_ptr (get_type (ref))) { - internal_error (ref, "expected pointer in ref"); - } - if (ref->type != ex_alias || ref->e.alias.offset) { - // probably just a pointer - sblock = statement_subexpr (sblock, ref, base); - *offset = short_operand (0, ref); - *mode = 2; // mode C: ptr + constant index - } else { - // alias with no offset - if (!is_integral (get_type (ref->e.alias.expr))) { - internal_error (ref, "expected integer expr in ref"); - } - expr_t *intptr = ref->e.alias.expr; - if (intptr->type != ex_expr - || (intptr->e.expr.op != '+' - && intptr->e.expr.op != '-')) { - // treat ref as simple pointer - sblock = statement_subexpr (sblock, ref, base); - *offset = short_operand (0, ref); - *mode = 2; // mode C: ptr + constant index - } else { - expr_t *ptr = intptr->e.expr.e1; - expr_t *offs = intptr->e.expr.e2; - int const_offs; - // move the +/- to the offset - offs = unary_expr (intptr->e.expr.op, offs); - // make the base a pointer again - ptr = new_alias_expr (ref->e.alias.type, ptr); - sblock = statement_subexpr (sblock, ptr, base); - if (is_constant (offs) - && (const_offs = expr_int (offs)) < 32768 - && const_offs >= -32768) { - *mode = 2; - *offset = short_operand (const_offs, ref); - } else { - *mode = 3; - sblock = statement_subexpr (sblock, offs, offset); - } - } - } + sblock = ptr_addressing_mode (sblock, ref->e.expr.e1, base, offset, + mode); } else { internal_error (ref, "unexpected expression type for indirect: %s", expr_names[ref->type]); From d3764c108a006068b9dcd2e924a9f9142f621095 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 28 Jan 2022 15:42:06 +0900 Subject: [PATCH 248/360] [qfcc] Rewrite expr_deref to use addressing_mode This cleans up the generation of load instructions such that they use ptr+offset addressing instead of lea;load ptr. --- tools/qfcc/source/statements.c | 73 ++++++++++++++-------------------- 1 file changed, 30 insertions(+), 43 deletions(-) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 91afd76d5..4685dede6 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1432,52 +1432,39 @@ load_statement (operand_t *ptr, operand_t *offs, operand_t *op, expr_t *e) static sblock_t * expr_deref (sblock_t *sblock, expr_t *deref, operand_t **op) { - type_t *type = deref->e.expr.type; - expr_t *e; + type_t *load_type = deref->e.expr.type; + expr_t *ptr_expr = deref->e.expr.e1; + operand_t *base = 0; + operand_t *offset = 0; + pr_ushort_t mode; - e = deref->e.expr.e1; - if (e->type == ex_address && !e->e.address.offset - && e->e.address.lvalue->type == ex_symbol) { - if (e->e.expr.e1->e.symbol->sy_type != sy_var) - internal_error (e, "address of non-var"); - *op = def_operand (e->e.expr.e1->e.symbol->s.def, type, e); - } else if (e->type == ex_address && e->e.address.offset) { - statement_t *s; - operand_t *ptr = 0; - operand_t *offs = 0; - sblock = statement_subexpr (sblock, e->e.address.lvalue, &ptr); - sblock = statement_subexpr (sblock, e->e.address.offset, &offs); - if (!*op) - *op = temp_operand (type, e); - if (low_level_type (type) == ev_void) { - s = lea_statement (ptr, offs, e); - sblock_add_statement (sblock, s); + sblock = addressing_mode (sblock, deref, &base, &offset, &mode); - s = movep_statement (*op, s->opc, type, deref); - sblock_add_statement (sblock, s); - } else { - s = load_statement (ptr, offs, *op, deref); - sblock_add_statement (sblock, s); - } - } else if (e->type == ex_value && e->e.value->lltype == ev_ptr) { - ex_pointer_t *ptr = &e->e.value->v.pointer; - *op = def_operand (alias_def (ptr->def, ptr->type, ptr->val), - ptr->type, e); - } else { - statement_t *s; - operand_t *ptr = 0; - - sblock = statement_subexpr (sblock, e, &ptr); - if (!*op) - *op = temp_operand (type, e); - if (low_level_type (type) == ev_void) { - s = movep_statement (*op, ptr, type, deref); - sblock_add_statement (sblock, s); - } else { - s = load_statement (ptr, short_operand (0, e), *op, deref); - sblock_add_statement (sblock, s); - } + switch (mode) { + case 1://entity.field + case 2://const indexed pointer + case 3://var indexed pointer + break; + default: + internal_error (deref, "unexpected addressing mode: %d", mode); } + + if (!*op) { + *op = temp_operand (load_type, deref); + } + + statement_t *s; + if (low_level_type (load_type) == ev_void) { + s = lea_statement (base, offset, ptr_expr); + sblock_add_statement (sblock, s); + + s = movep_statement (*op, s->opc, load_type, deref); + sblock_add_statement (sblock, s); + } else { + s = load_statement (base, offset, *op, deref); + sblock_add_statement (sblock, s); + } + return sblock; } From 284fcd312d78baaa4b26f22865e19ce354848de6 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 28 Jan 2022 15:46:29 +0900 Subject: [PATCH 249/360] [qfcc] Rewrite assignment destination addressing It now addressing_mode cleaning up store instructions to use ptr+offset instead of lea;store ptr... Entity.field addressing has been impelmented as well. Move instructions still generate sub-optimal code in that they use an add instruction instead of lea. --- tools/qfcc/source/statements.c | 53 ++++++++++++++-------------------- 1 file changed, 22 insertions(+), 31 deletions(-) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 4685dede6..064e25cb5 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -792,17 +792,6 @@ operand_address (operand_t *reference, expr_t *e) op_type_names[reference->op_type]); } -static __attribute__((pure)) int -is_const_ptr (expr_t *e) -{ - if ((e->type != ex_value || e->e.value->lltype != ev_ptr) - || !(POINTER_VAL (e->e.value->v.pointer) >= 0 - && POINTER_VAL (e->e.value->v.pointer) < 65536)) { - return 0; - } - return 1; -} - static __attribute__((pure)) int is_indirect (expr_t *e) { @@ -813,6 +802,10 @@ is_indirect (expr_t *e) return 0; } +static sblock_t *addressing_mode (sblock_t *sblock, expr_t *ref, + operand_t **base, operand_t **offset, + pr_ushort_t *mode); + static sblock_t * expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) { @@ -916,6 +909,7 @@ expr_assign (sblock_t *sblock, expr_t *e, operand_t **op) operand_t *src = 0; operand_t *dst = 0; operand_t *ofs = 0; + pr_ushort_t mode = 0; // assign const char *opcode = "assign"; st_type_t type; @@ -957,26 +951,10 @@ expr_assign (sblock_t *sblock, expr_t *e, operand_t **op) if (0) { dereference_dst: - // dst_expr is a dereferenced pointer, so need to un-dereference it - // to get the pointer and switch to storep instructions. - dst_expr = expr_file_line (address_expr (dst_expr, 0), e); + // dst_expr is a dereferenced pointer, so need to get its addressing + // parameters (base and offset) and switch to storep instructions. + sblock = addressing_mode (sblock, dst_expr, &dst, &ofs, &mode); opcode = "store"; - if (dst_expr->type == ex_address && dst_expr->e.address.offset - && !is_const_ptr (dst_expr->e.address.lvalue)) { - sblock = statement_subexpr (sblock, - dst_expr->e.address.lvalue, &dst); - sblock = statement_subexpr (sblock, - dst_expr->e.address.offset, &ofs); - } else { - sblock = statement_subexpr (sblock, dst_expr, &dst); - if (options.code.progsversion < PROG_VERSION) { - // v6 and v6p stores don't need an index - ofs = 0; - } else { - // ruamoko stores do need an index - ofs = short_operand (0, e); - } - } type = st_ptrassign; } if (op) { @@ -987,6 +965,10 @@ dereference_dst: } if (is_entity (dst->type) && ofs && is_field (ofs->type)) { + // need to get a pointer type, entity.field expressions do not provide + // one directly. FIXME it was probably a mistake extracting the operand + // type from the statement expression in dags + dst_expr = expr_file_line (address_expr (dst_expr, 0), dst_expr); s = new_statement (st_expr, "lea", dst_expr); s->opa = dst; s->opb = ofs; @@ -1316,7 +1298,16 @@ addressing_mode (sblock_t *sblock, expr_t *ref, // ref is known to be either ex_expr or ex_uexpr, with '.' for // the operator if (ref->type == ex_expr) { - internal_error (ref, "not implemented"); + expr_t *ent_expr = ref->e.expr.e1; + expr_t *fld_expr = ref->e.expr.e2; + if (!is_entity (get_type (ent_expr)) + || !is_field (get_type (fld_expr))) { + print_expr (ref); + internal_error (ref, "expected entity.field"); + } + sblock = statement_subexpr (sblock, ent_expr, base); + sblock = statement_subexpr (sblock, fld_expr, offset); + *mode = 1;//entity.field } else if (ref->type == ex_uexpr) { sblock = ptr_addressing_mode (sblock, ref->e.expr.e1, base, offset, mode); From 54e079ab754e74dd95258e99d7116a17ed9cf471 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 29 Jan 2022 15:38:39 +0900 Subject: [PATCH 250/360] [qfcc] Fold int constants more aggressively This code now reaches into one level of the expression tree and rearranges the nodes to allow the constant folder to do its things, but only for ints, and only when the folding is trivially correct (* and *, +/- and +/-). There may be more opportunities, but these cover what I needed for now and anything more will need code generation or smarter tree manipulation as things are getting out of hand. --- tools/qfcc/source/constfold.c | 66 +++++++++++++++++++++++++++ tools/qfcc/test/Makemodule.am | 11 +++++ tools/qfcc/test/const-fold-int.r | 76 ++++++++++++++++++++++++++++++++ 3 files changed, 153 insertions(+) create mode 100644 tools/qfcc/test/const-fold-int.r diff --git a/tools/qfcc/source/constfold.c b/tools/qfcc/source/constfold.c index c09f82257..ae36079b3 100644 --- a/tools/qfcc/source/constfold.c +++ b/tools/qfcc/source/constfold.c @@ -80,6 +80,18 @@ cmp_result_expr (int result) } } +static int +is_addsub (int op) +{ + return op == '+' || op == '-'; +} + +static int +inv_addsub (int op) +{ + return op == '+' ? '-' : '+'; +} + static expr_t * do_op_string (int op, expr_t *e, expr_t *e1, expr_t *e2) { @@ -819,6 +831,60 @@ do_op_int (int op, expr_t *e, expr_t *e1, expr_t *e2) if (op == '-' && isval2 && val2 == 0) return e1; + if (!isval1) { + if (e1->type == ex_expr) { + // at most one of the two sub-expressions is constant otherwise + // e1 would be a constant + if (is_constant (e1->e.expr.e1)) { + if ((op == '*' && e1->e.expr.op == '*') + || (is_addsub (op) && is_addsub (e1->e.expr.op))) { + expr_t *c = binary_expr (op, e1->e.expr.e1, e2); + e = binary_expr (e1->e.expr.op, c, e1->e.expr.e2); + } + } else if (is_constant (e1->e.expr.e2)) { + if ((op == '*' && e1->e.expr.op == '*') + || (is_addsub (op) && e1->e.expr.op == '+')) { + expr_t *c = binary_expr (op, e1->e.expr.e2, e2); + e = binary_expr (e1->e.expr.op, e1->e.expr.e1, c); + } else if (is_addsub (op) && e1->e.expr.op == '-') { + // must ivert op + expr_t *c = binary_expr (inv_addsub (op), + e1->e.expr.e2, e2); + e = binary_expr (e1->e.expr.op, e1->e.expr.e1, c); + } + } + } + return e; + } else if (!isval2) { + if (e2->type == ex_expr) { + // at most one of the two sub-expressions is constant otherwise + // e2 would be a constant + if (is_constant (e2->e.expr.e1)) { + if ((op == '*' && e2->e.expr.op == '*') + || (op == '+' && is_addsub (e2->e.expr.op))) { + expr_t *c = binary_expr (op, e1, e2->e.expr.e1); + e = binary_expr (e2->e.expr.op, c, e2->e.expr.e2); + } else if (op == '-' && is_addsub (e2->e.expr.op)) { + expr_t *c = binary_expr (op, e1, e2->e.expr.e1); + c = fold_constants (c); + e = binary_expr (inv_addsub (e2->e.expr.op), + c, e2->e.expr.e2); + } + } else if (is_constant (e2->e.expr.e2)) { + if ((op == '*' && e2->e.expr.op == '*') + || (op == '+' && is_addsub (e2->e.expr.op))) { + expr_t *c = binary_expr (e2->e.expr.op, + e1, e2->e.expr.e2); + e = binary_expr (op, c, e2->e.expr.e1); + } else if (op == '-' && is_addsub (e2->e.expr.op)) { + expr_t *c = binary_expr (inv_addsub (e2->e.expr.op), + e1, e2->e.expr.e2); + e = binary_expr (op, c, e2->e.expr.e1); + } + } + } + return e; + } if (!isval1 || !isval2) return e; diff --git a/tools/qfcc/test/Makemodule.am b/tools/qfcc/test/Makemodule.am index f555e89f1..acfa99873 100644 --- a/tools/qfcc/test/Makemodule.am +++ b/tools/qfcc/test/Makemodule.am @@ -16,6 +16,7 @@ test_progs_dat=\ tools/qfcc/test/chewed-return.dat \ tools/qfcc/test/comma-expr.dat \ tools/qfcc/test/compound.dat \ + tools/qfcc/test/const-fold-int.dat \ tools/qfcc/test/deadbool.dat \ tools/qfcc/test/dealloc-nowarn.dat \ tools/qfcc/test/dealloc-nowarn2.dat \ @@ -195,6 +196,16 @@ tools/qfcc/test/compound.run: $(qfcc_test_run_deps) include $(compound_dep) # am--include-marker r_depfiles_remade += $(compound_dep) +tools_qfcc_test_const_fold_int_dat_SOURCES=tools/qfcc/test/const-fold-int.r +const_fold_int_obj=$(tools_qfcc_test_const_fold_int_dat_SOURCES:.r=.o) +const_fold_int_dep=$(call qcautodep,$(tools_qfcc_test_const_fold_int_dat_SOURCES)) +tools/qfcc/test/const-fold-int.dat$(EXEEXT): $(const_fold_int_obj) $(QFCC_DEP) + $(V_QFCCLD)$(QLINK) -o $@ $(const_fold_int_obj) +tools/qfcc/test/const-fold-int.run: $(qfcc_test_run_deps) + @$(top_srcdir)/tools/qfcc/test/build-run $@ +include $(const_fold_int_dep) # am--include-marker +r_depfiles_remade += $(const_fold_int_dep) + tools_qfcc_test_deadbool_dat_SOURCES=tools/qfcc/test/deadbool.r deadbool_obj=$(tools_qfcc_test_deadbool_dat_SOURCES:.r=.o) deadbool_dep=$(call qcautodep,$(tools_qfcc_test_deadbool_dat_SOURCES)) diff --git a/tools/qfcc/test/const-fold-int.r b/tools/qfcc/test/const-fold-int.r new file mode 100644 index 000000000..d7fa31920 --- /dev/null +++ b/tools/qfcc/test/const-fold-int.r @@ -0,0 +1,76 @@ +int mul_e_c_t_c (int x) { return x * 6 * 7; } +int mul_c_e_t_c (int x) { return 6 * x * 7; } +int mul_c_c_t_e (int x) { return 6 * 7 * x; } +int mul_e_t_c_c (int x) { return x * (6 * 7); } +int mul_c_t_e_c (int x) { return 6 * (x * 7); } +int mul_c_t_c_e (int x) { return 6 * (7 * x); } + +int addadd_e_c_t_c (int x) { return x + 6 + 7; } +int addadd_c_e_t_c (int x) { return 6 + x + 7; } +int addadd_c_c_t_e (int x) { return 6 + 7 + x; } +int addadd_e_t_c_c (int x) { return x + (6 + 7); } +int addadd_c_t_e_c (int x) { return 6 + (x + 7); } +int addadd_c_t_c_e (int x) { return 6 + (7 + x); } + +int addsub_e_c_t_c (int x) { return x + 6 - 7; } +int addsub_c_e_t_c (int x) { return 6 + x - 7; } +int addsub_c_c_t_e (int x) { return 6 + 7 - x; } +int addsub_e_t_c_c (int x) { return x + (6 - 7); } +int addsub_c_t_e_c (int x) { return 6 + (x - 7); } +int addsub_c_t_c_e (int x) { return 6 + (7 - x); } + +int subadd_e_c_t_c (int x) { return x - 6 + 7; } +int subadd_c_e_t_c (int x) { return 6 - x + 7; } +int subadd_c_c_t_e (int x) { return 6 - 7 + x; } +int subadd_e_t_c_c (int x) { return x - (6 + 7); } +int subadd_c_t_e_c (int x) { return 6 - (x + 7); } +int subadd_c_t_c_e (int x) { return 6 - (7 + x); } + +int subsub_e_c_t_c (int x) { return x - 6 - 7; } +int subsub_c_e_t_c (int x) { return 6 - x - 7; } +int subsub_c_c_t_e (int x) { return 6 - 7 - x; } +int subsub_e_t_c_c (int x) { return x - (6 - 7); } +int subsub_c_t_e_c (int x) { return 6 - (x - 7); } +int subsub_c_t_c_e (int x) { return 6 - (7 - x); } + +int +main () +{ + int fail = 0; + + fail |= mul_e_c_t_c (10) != 420; + fail |= mul_c_e_t_c (10) != 420; + fail |= mul_c_c_t_e (10) != 420; + fail |= mul_e_t_c_c (10) != 420; + fail |= mul_c_t_e_c (10) != 420; + fail |= mul_c_t_c_e (10) != 420; + + fail |= addadd_e_c_t_c (29) != 42; + fail |= addadd_c_e_t_c (29) != 42; + fail |= addadd_c_c_t_e (29) != 42; + fail |= addadd_e_t_c_c (29) != 42; + fail |= addadd_c_t_e_c (29) != 42; + fail |= addadd_c_t_c_e (29) != 42; + + fail |= addsub_e_c_t_c (43) != 42; + fail |= addsub_c_e_t_c (43) != 42; + fail |= addsub_c_c_t_e (-29) != 42; + fail |= addsub_e_t_c_c (43) != 42; + fail |= addsub_c_t_e_c (43) != 42; + fail |= addsub_c_t_c_e (-29) != 42; + + fail |= subadd_e_c_t_c (41) != 42; + fail |= subadd_c_e_t_c (-29) != 42; + fail |= subadd_c_c_t_e (43) != 42; + fail |= subadd_e_t_c_c (55) != 42; + fail |= subadd_c_t_e_c (-43) != 42; + fail |= subadd_c_t_c_e (-43) != 42; + + fail |= subsub_e_c_t_c (55) != 42; + fail |= subsub_c_e_t_c (-43) != 42; + fail |= subsub_c_c_t_e (-43) != 42; + fail |= subsub_e_t_c_c (41) != 42; + fail |= subsub_c_t_e_c (-29) != 42; + fail |= subsub_c_t_c_e (43) != 42; + return fail; +} From 10843fe340835f168f57383b588ce5546d552cdb Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 29 Jan 2022 17:05:10 +0900 Subject: [PATCH 251/360] [gamecode] Correct memset opname and types --- libs/gamecode/opcodes.py | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index a7fc99a22..703baf183 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -254,12 +254,13 @@ mathops_formats = { memset_formats = { "opcode": "OP_MEMSET_{op_memset[oo].upper()}", "mnemonic": "memset.{op_memset[oo]}", - "opname": "memset{op_memset[oo]}", + "opname": "memset{suff_memset[oo]}", "format": "{memset_fmt[oo]}", "widths": "{memset_widths[oo]}", "types": "{memset_types[oo]}", "args": { "op_memset": ["i", "p", "pi", None], + "suff_memset": ["", "p", "p", None], "memset_fmt": ["%Ga, %sb, %gc", "%Ga, %Gb, %Gc", "%Ga, %sb, %Gc", None], "memset_widths": [ "1, 0, -1", @@ -268,9 +269,9 @@ memset_formats = { None, ], "memset_types": [ - "ev_void, ev_short, ev_void", - "ev_ptr, ev_int, ev_ptr", - "ev_ptr, ev_short, ev_ptr", + "ev_int, ev_short, ev_void", + "ev_int, ev_int, ev_ptr", + "ev_int, ev_short, ev_ptr", ], }, } From d61e906cb9caa16d73fc6273a4dd670aecdbee3b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 29 Jan 2022 17:05:50 +0900 Subject: [PATCH 252/360] [qfcc] Don't use v6p store for assinging to entity.field Ruamoko has a native addressing mode just for entities. --- tools/qfcc/source/statements.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 064e25cb5..aa70b2713 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -964,7 +964,8 @@ dereference_dst: return sblock; } - if (is_entity (dst->type) && ofs && is_field (ofs->type)) { + if (options.code.progsversion < PROG_VERSION + && is_entity (dst->type) && ofs && is_field (ofs->type)) { // need to get a pointer type, entity.field expressions do not provide // one directly. FIXME it was probably a mistake extracting the operand // type from the statement expression in dags From baca7cbb4c5790a906a186dc3f07280fbed64452 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 29 Jan 2022 17:07:19 +0900 Subject: [PATCH 253/360] [qfcc] Do not reverse function args in ruamoko call It messed up the later check for calls to i[super dealloc]. --- tools/qfcc/source/statements.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index aa70b2713..c2387cec8 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1096,7 +1096,7 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) } defspace_t *arg_space = current_func->arguments; expr_t *func = call->e.branch.target; - expr_t *args = call->e.branch.args; + expr_t **args = 0; expr_t *args_va_list = 0; // .args (...) parameter expr_t *args_params = 0; // first arg in ... operand_t *use = 0; @@ -1105,9 +1105,20 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) defspace_reset (arg_space); - args = reverse_expr_list (args); + int num_args = 0; + for (expr_t *a = call->e.branch.args; a; a = a->next) { + num_args++; + } + if (num_args) { + int i = num_args; + args = alloca (num_args * sizeof (expr_t *)); + for (expr_t *a = call->e.branch.args; a; a = a->next) { + args[--i] = a; + } + } int arg_num = 0; - for (expr_t *a = args; a; a = a->next) { + for (int i = 0; i < num_args; i++) { + expr_t *a = args[i]; const char *arg_name = va (0, ".arg%d", arg_num++); def_t *def = new_def (arg_name, 0, current_func->arguments, sc_local); From 7e9cf76cfefafb00f5f69d9318554d2d556afa1a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 29 Jan 2022 18:18:33 +0900 Subject: [PATCH 254/360] [qfcc] Change ne to cmp for v6 string inequality check Since it's really strcmp in disguise (makes the instruction consistent across all targets). --- libs/gamecode/pr_v6p_opcode.c | 2 +- tools/qfcc/source/statements.c | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index cb11c9eca..c99ef1580 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -236,7 +236,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { ev_quaternion, ev_quaternion, ev_int, PROG_V6P_VERSION, }, - [OP_NE_S_v6p] = {"ne", "ne.s", + [OP_NE_S_v6p] = {"cmp", "ne.s", ev_string, ev_string, ev_int, PROG_ID_VERSION, }, diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index c2387cec8..f81807a82 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1548,6 +1548,9 @@ expr_expr (sblock_t *sblock, expr_t *e, operand_t **op) opcode = convert_op (e->e.expr.op); if (!opcode) internal_error (e, "ice ice baby"); + if (strcmp (opcode, "ne") == 0 && is_string (get_type (e->e.expr.e1))) { + opcode = "cmp"; + } s = new_statement (st_expr, opcode, e); sblock = statement_subexpr (sblock, e->e.expr.e1, &s->opa); sblock = statement_subexpr (sblock, e->e.expr.e2, &s->opb); From 501dd7db76dc9b4a2a4a43158f30f315220291b3 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 29 Jan 2022 18:22:41 +0900 Subject: [PATCH 255/360] [qfcc] Use != nil for unary ! for Ruamoko progs Ruamoko has no explicit ! instruction. --- tools/qfcc/source/expr.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index c9e36c7b2..0b67687e1 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1951,7 +1951,9 @@ unary_expr (int op, expr_t *e) case ex_alias: case ex_address: case ex_assign: - { + if (options.code.progsversion == PROG_VERSION) { + return binary_expr (EQ, e, new_nil_expr ()); + } else { expr_t *n = new_unary_expr (op, e); if (options.code.progsversion > PROG_ID_VERSION) From f853a449b8cc2ead617472582d88ac890dc97c29 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 29 Jan 2022 18:23:07 +0900 Subject: [PATCH 256/360] [qfcc] Cast pointers to ints for comparison Ruamoko doesn't wast instructions on otherwise compatible low-level types. --- tools/qfcc/source/expr_binary.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index 06fdb6668..1e82916f8 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -686,7 +686,12 @@ pointer_compare (int op, expr_t *e1, expr_t *e2) return error (e2, "cannot use %s on pointers of different types", get_op_string (op)); } - e = new_binary_expr (op, e1, e2); + if (options.code.progsversion < PROG_VERSION) { + e = new_binary_expr (op, e1, e2); + } else { + e = new_binary_expr (op, cast_expr (&type_int, e1), + cast_expr (&type_int, e2)); + } e->e.expr.type = &type_int; return e; } From fbaf1456feb53e57cd3fc8bc433c7019050b5e9b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 29 Jan 2022 18:24:16 +0900 Subject: [PATCH 257/360] [qfcc] Use auxiliary operands for move instructions Since Ruamoko progs must use lea to get the address of a local variable, add use/def/kill references to the move instruction in order to inform flow analysis of the variable since it is otherwise lost via the resulting pointer (not an issue when direct var reference move can be used). The test and digging for the def can probably do with being more aggressive, but this did nicely as a proof of concept. --- tools/qfcc/include/expr.h | 8 ++++++++ tools/qfcc/source/expr.c | 14 ++++++++++++++ tools/qfcc/source/statements.c | 17 +++++++++++++++++ 3 files changed, 39 insertions(+) diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 641b04246..f2b934324 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -629,6 +629,14 @@ int expr_integral (expr_t *e) __attribute__((pure)); */ int is_constant (expr_t *e) __attribute__((pure)); +/** Check if the expression refers to a variable. + + \param e The expression to check. + \return True if the expression refers to a variable (def + expression, var symbol expression, or temp expression). +*/ +int is_variable (expr_t *e) __attribute__((pure)); + /** Check if the expression refers to a selector \param e The expression to check. diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 0b67687e1..66140bc52 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -956,6 +956,20 @@ is_constant (expr_t *e) return 0; } +int +is_variable (expr_t *e) +{ + while (e->type == ex_alias) { + e = e->e.alias.expr; + } + if (e->type == ex_def + || (e->type == ex_symbol && e->e.symbol->sy_type == sy_var) + || e->type == ex_temp) { + return 1; + } + return 0; +} + int is_selector (expr_t *e) { diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index f81807a82..2ade73a9f 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -827,6 +827,9 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) const char *opcode; int need_ptr = 0; st_type_t type = st_move; + operand_t *use = 0; + operand_t *def = 0; + operand_t *kill = 0; if ((src && src->op_type == op_nil) || src_expr->type == ex_nil) { // switch to memset because nil is type agnostic 0 and structures @@ -859,6 +862,11 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) *op = src; } if (is_indirect (dst_expr)) { + if (is_variable (src_expr)) { + // FIXME this probably needs to be more agressive + // shouldn't emit code... + sblock = statement_subexpr (sblock, src_expr, &use); + } src = operand_address (src, src_expr); need_ptr = 1; } @@ -867,6 +875,12 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) // dst_expr and/or src_expr are dereferenced pointers, so need to // un-dereference dst_expr to get the pointer and switch to movep // or memsetp instructions. + if (is_variable (dst_expr)) { + // FIXME this probably needs to be more agressive + // shouldn't emit code... + sblock = statement_subexpr (sblock, dst_expr, &def); + sblock = statement_subexpr (sblock, dst_expr, &kill); + } dst_expr = expr_file_line (address_expr (dst_expr, 0), e); need_ptr = 1; } @@ -895,6 +909,9 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) s->opa = src; s->opb = size; s->opc = dst; + s->use = use; + s->def = def; + s->kill = kill; sblock_add_statement (sblock, s); return sblock; } From 49395b3ba1b05a049883cc40c8fae9902bb3c10a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 29 Jan 2022 18:48:05 +0900 Subject: [PATCH 258/360] [gamecode] Correct state's types for double time It takes int for the frame rather than float. --- libs/gamecode/opcodes.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 703baf183..d2da04ed7 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -394,7 +394,7 @@ stated_formats = { "opname": "state", "format": "{state_fmt[c]}", "widths": "1, 1, {c}", - "types": "ev_float, ev_func, {state_types[c]}", + "types": "ev_int, ev_func, {state_types[c]}", "args": { "state": ["dt", "dtt"], "state_fmt": ["%Ga, %Gb", "%Ga, %Gb, %Gc"], From 61727941fda04f802aa3cc4562d737d2934498cd Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 29 Jan 2022 18:57:48 +0900 Subject: [PATCH 259/360] [qfcc] Prepend state epxression instead of just linking This fixes an expression loop ICE when building for Ruamoko (not that there actually was a loop, but the test is rather simplistic). --- tools/qfcc/source/function.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index 97481dee8..aa4f79134 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -724,8 +724,7 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements) return 0; build_function (fsym); if (state_expr) { - state_expr->next = statements; - statements = state_expr; + prepend_expr (statements, state_expr); } function_t *func = fsym->s.func; if (options.code.progsversion == PROG_VERSION) { From 5ba6bf02e8e0666e5d2b444bd3a658f636109ece Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 29 Jan 2022 18:59:38 +0900 Subject: [PATCH 260/360] [qfcc] Cast functions to ints for comparison Yet more (non-)wasted instructions. --- tools/qfcc/source/expr_binary.c | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index 1e82916f8..c2acf4028 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -48,6 +48,7 @@ typedef struct { static expr_t *pointer_arithmetic (int op, expr_t *e1, expr_t *e2); static expr_t *pointer_compare (int op, expr_t *e1, expr_t *e2); +static expr_t *func_compare (int op, expr_t *e1, expr_t *e2); static expr_t *inverse_multiply (int op, expr_t *e1, expr_t *e2); static expr_t *double_compare (int op, expr_t *e1, expr_t *e2); @@ -172,8 +173,8 @@ static expr_type_t field_field[] = { }; static expr_type_t func_func[] = { - {EQ, &type_int}, - {NE, &type_int}, + {EQ, 0, 0, 0, func_compare}, + {NE, 0, 0, 0, func_compare}, {0, 0} }; @@ -696,6 +697,21 @@ pointer_compare (int op, expr_t *e1, expr_t *e2) return e; } +static expr_t * +func_compare (int op, expr_t *e1, expr_t *e2) +{ + expr_t *e; + + if (options.code.progsversion < PROG_VERSION) { + e = new_binary_expr (op, e1, e2); + } else { + e = new_binary_expr (op, new_alias_expr (&type_int, e1), + new_alias_expr (&type_int, e2)); + } + e->e.expr.type = &type_int; + return e; +} + static expr_t * inverse_multiply (int op, expr_t *e1, expr_t *e2) { From 728c42e921aeb34620b06fea23db97609cbafee0 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 10:47:37 +0900 Subject: [PATCH 261/360] [gamecode] Use pr_type_names for debug views I abandoned the reason for doing it (adding a pile of vector types), but I liked the cleanup. All the implementations are hand-written still, but at least the boilerplate stuff is automated. --- include/QF/progs.h | 19 +---- include/QF/progs/pr_comp.h | 14 +++- include/QF/progs/pr_type_names.h | 2 +- libs/gamecode/pr_debug.c | 118 +++++-------------------------- 4 files changed, 34 insertions(+), 119 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index f8ef4abfd..769fdb533 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1794,28 +1794,13 @@ typedef void (*type_view_func) (struct qfot_type_s *type, pr_type_t *value, the entire contents of the data. */ typedef struct type_view_s { - type_view_func void_view; - type_view_func string_view; - type_view_func float_view; - type_view_func vector_view; - type_view_func entity_view; - type_view_func field_view; - type_view_func func_view; - type_view_func pointer_view; - type_view_func quat_view; - type_view_func int_view; - type_view_func uint_view; - type_view_func short_view; - type_view_func double_view; - type_view_func long_view; - type_view_func ulong_view; - type_view_func ushort_view; - type_view_func struct_view; type_view_func union_view; type_view_func enum_view; type_view_func array_view; type_view_func class_view; +#define EV_TYPE(type) type_view_func type##_view; +#include "QF/progs/pr_type_names.h" } type_view_t; void PR_Debug_Init (progs_t *pr); diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index d201bff87..1012f320d 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -43,18 +43,30 @@ typedef uint16_t pr_ushort_t __attribute__((aligned(2)));; typedef t n __attribute__ ((vector_size (s*sizeof (t)))) PR_VEC_TYPE (pr_int_t, pr_ivec2_t, 2); +typedef pr_int_t pr_ivec3_t[3]; PR_VEC_TYPE (pr_int_t, pr_ivec4_t, 4); + PR_VEC_TYPE (pr_uint_t, pr_uivec2_t, 2); +typedef pr_uint_t pr_uivec3_t[3]; PR_VEC_TYPE (pr_uint_t, pr_uivec4_t, 4); + PR_VEC_TYPE (float, pr_vec2_t, 2); +typedef pr_float_t pr_vec3_t[3]; PR_VEC_TYPE (float, pr_vec4_t, 4); + PR_VEC_TYPE (pr_long_t, pr_lvec2_t, 2); +typedef pr_long_t pr_lvec3_t[3]; PR_VEC_TYPE (pr_long_t, pr_lvec4_t, 4); + PR_VEC_TYPE (pr_ulong_t, pr_ulvec2_t, 2); +typedef pr_ulong_t pr_ulvec3_t[3]; PR_VEC_TYPE (pr_ulong_t, pr_ulvec4_t, 4); + PR_VEC_TYPE (double, pr_dvec2_t, 2); +typedef pr_double_t pr_dvec3_t[3]; PR_VEC_TYPE (double, pr_dvec4_t, 4); + #define EV_TYPE(type) ev_##type, typedef enum { #include "QF/progs/pr_type_names.h" @@ -62,7 +74,7 @@ typedef enum { ev_type_count // not a type, gives number of types } etype_t; -#define PR_SIZEOF(type) (sizeof (pr_##type##_t) / sizeof (pr_int_t)) +#define PR_SIZEOF(type) (sizeof (pr_##type##_t) / (sizeof (pr_int_t))) #define PR_ALIGNOF(type) (__alignof__ (pr_##type##_t) / __alignof__ (pr_int_t)) extern const pr_ushort_t pr_type_size[ev_type_count]; diff --git a/include/QF/progs/pr_type_names.h b/include/QF/progs/pr_type_names.h index 5e9904b2a..3e0daf10a 100644 --- a/include/QF/progs/pr_type_names.h +++ b/include/QF/progs/pr_type_names.h @@ -45,6 +45,6 @@ EV_TYPE(short) // value is embedded in the opcode EV_TYPE(double) EV_TYPE(long) EV_TYPE(ulong) -EV_TYPE(ushort) +EV_TYPE(ushort) // value is embedded in the opcode #undef EV_TYPE diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index b9c3862c5..041963233 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -59,6 +59,7 @@ #include "QF/progs/pr_debug.h" #include "QF/progs/pr_type.h" +#include "QF/simd/types.h" #include "compat.h" @@ -121,38 +122,6 @@ cvar_t *pr_source_path; static char *source_path_string; static char **source_paths; -static void pr_debug_void_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_string_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_float_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_vector_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_entity_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_field_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_func_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_pointer_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_quat_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_int_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_uint_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_short_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_double_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_long_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_ulong_view (qfot_type_t *type, pr_type_t *value, - void *_data); -static void pr_debug_ushort_view (qfot_type_t *type, pr_type_t *value, - void *_data); static void pr_debug_struct_view (qfot_type_t *type, pr_type_t *value, void *_data); static void pr_debug_union_view (qfot_type_t *type, pr_type_t *value, @@ -163,29 +132,20 @@ static void pr_debug_array_view (qfot_type_t *type, pr_type_t *value, void *_data); static void pr_debug_class_view (qfot_type_t *type, pr_type_t *value, void *_data); +#define EV_TYPE(t) \ + static void pr_debug_##t##_view (qfot_type_t *type, pr_type_t *value, \ + void *_data); +#include "QF/progs/pr_type_names.h" static type_view_t raw_type_view = { - pr_debug_void_view, - pr_debug_string_view, - pr_debug_float_view, - pr_debug_vector_view, - pr_debug_entity_view, - pr_debug_field_view, - pr_debug_func_view, - pr_debug_pointer_view, - pr_debug_quat_view, - pr_debug_int_view, - pr_debug_uint_view, - pr_debug_short_view, - pr_debug_double_view, - pr_debug_long_view, - pr_debug_ulong_view, - pr_debug_ushort_view, pr_debug_struct_view, pr_debug_union_view, pr_debug_enum_view, pr_debug_array_view, pr_debug_class_view, +#define EV_TYPE(t) \ + pr_debug_##t##_view, +#include "QF/progs/pr_type_names.h" }; static const char * @@ -1040,60 +1000,18 @@ PR_DumpState (progs_t *pr) #define ISDENORM(x) ((x) && !((x) & 0x7f800000)) -static const char * +static void value_string (pr_debug_data_t *data, qfot_type_t *type, pr_type_t *value) { switch (type->meta) { case ty_basic: switch (type->type) { - case ev_void: - raw_type_view.void_view (type, value, data); - break; - case ev_string: - raw_type_view.string_view (type, value, data); - break; - case ev_float: - raw_type_view.float_view (type, value, data); - break; - case ev_vector: - raw_type_view.vector_view (type, value, data); - break; - case ev_entity: - raw_type_view.entity_view (type, value, data); - break; - case ev_field: - raw_type_view.field_view (type, value, data); - break; - case ev_func: - raw_type_view.func_view (type, value, data); - break; - case ev_ptr: - raw_type_view.pointer_view (type, value, data); - break; - case ev_quaternion: - raw_type_view.quat_view (type, value, data); - break; - case ev_int: - raw_type_view.int_view (type, value, data); - break; - case ev_uint: - raw_type_view.uint_view (type, value, data); - break; - case ev_short: - raw_type_view.short_view (type, value, data); - break; - case ev_double: - raw_type_view.double_view (type, value, data); - break; - case ev_long: - raw_type_view.long_view (type, value, data); - break; - case ev_ulong: - raw_type_view.ulong_view (type, value, data); - break; - case ev_ushort: - raw_type_view.ushort_view (type, value, data); +#define EV_TYPE(t) \ + case ev_##t: \ + raw_type_view.t##_view (type, value, data); \ break; +#include "QF/progs/pr_type_names.h" + case ev_invalid: case ev_type_count: dstring_appendstr (data->dstr, ""); @@ -1116,9 +1034,9 @@ value_string (pr_debug_data_t *data, qfot_type_t *type, pr_type_t *value) break; case ty_alias://XXX type = &G_STRUCT (data->pr, qfot_type_t, type->alias.aux_type); - return value_string (data, type, value); + value_string (data, type, value); + break; } - return data->dstr->str; } static pr_def_t * @@ -1331,7 +1249,7 @@ pr_debug_func_view (qfot_type_t *type, pr_type_t *value, void *_data) } static void -pr_debug_pointer_view (qfot_type_t *type, pr_type_t *value, void *_data) +pr_debug_ptr_view (qfot_type_t *type, pr_type_t *value, void *_data) { __auto_type data = (pr_debug_data_t *) _data; progs_t *pr = data->pr; @@ -1353,7 +1271,7 @@ pr_debug_pointer_view (qfot_type_t *type, pr_type_t *value, void *_data) } static void -pr_debug_quat_view (qfot_type_t *type, pr_type_t *value, void *_data) +pr_debug_quaternion_view (qfot_type_t *type, pr_type_t *value, void *_data) { __auto_type data = (pr_debug_data_t *) _data; dstring_t *dstr = data->dstr; From c467217b4bac02305f2378ef8cef2ca6d490f2c3 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 10:50:14 +0900 Subject: [PATCH 262/360] [simd] Use inttypes.h for long vector formats Much nicer than cluttering up the headers with word-size checks. --- include/QF/simd/types.h | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/include/QF/simd/types.h b/include/QF/simd/types.h index 1f2a511c1..43d564745 100644 --- a/include/QF/simd/types.h +++ b/include/QF/simd/types.h @@ -29,6 +29,7 @@ #define __QF_simd_types_h #include +#include #define VEC_TYPE(t,n,s) \ typedef t n __attribute__ ((vector_size (s*sizeof (t)))) @@ -84,13 +85,9 @@ VEC_TYPE (float, vec4f_t, 4); VEC_TYPE (int, vec4i_t, 4); #define VEC2D_FMT "[%.17g, %.17g]" -#define VEC2L_FMT "[%ld, %ld]" +#define VEC2L_FMT "[%"PRIi64", %"PRIi64"]" #define VEC4D_FMT "[%.17g, %.17g, %.17g, %.17g]" -#if __WORDSIZE == 64 -#define VEC4L_FMT "[%ld, %ld, %ld, %ld]" -#else -#define VEC4L_FMT "[%lld, %lld, %lld, %lld]" -#endif +#define VEC4L_FMT "[%"PRIi64", %"PRIi64", %"PRIi64", %"PRIi64"]" #define VEC2F_FMT "[%.9g, %.9g]" #define VEC2I_FMT "[%d, %d]" #define VEC4F_FMT "[%.9g, %.9g, %.9g, %.9g]" From feb3be4e6b1878828cf2978b8ee84a93cd2d1235 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 10:54:07 +0900 Subject: [PATCH 263/360] [qfcc] Add types for ivec3/4 and vec3/4 Needed to get quaternions and vectors going. I'll add more later. --- tools/qfcc/include/type.h | 9 +++ tools/qfcc/source/class.c | 129 ++++++++++++++++++++++++++++------- tools/qfcc/source/function.c | 1 + tools/qfcc/source/opcodes.c | 26 ++++++- tools/qfcc/source/struct.c | 3 +- tools/qfcc/source/type.c | 126 +++++++++++++++++++++++++++++----- 6 files changed, 248 insertions(+), 46 deletions(-) diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h index b8cff36e5..2062933d6 100644 --- a/tools/qfcc/include/type.h +++ b/tools/qfcc/include/type.h @@ -60,6 +60,9 @@ typedef struct type_s { etype_t type; ///< ev_invalid means structure/array etc const char *name; int alignment; ///< required alignment for instances + int width; ///< components in vector types, otherwise 1 + ///< vector and quaternion are 1 (separate from + ///< vec3 and vec4) /// function/pointer/array/struct types are more complex ty_meta_e meta; union { @@ -99,6 +102,11 @@ typedef struct { #define EV_TYPE(type) extern type_t type_##type; #include "QF/progs/pr_type_names.h" +extern type_t type_ivec3; +extern type_t type_ivec4; +extern type_t type_vec3; +extern type_t type_vec4; + extern type_t type_invalid; extern type_t type_floatfield; @@ -158,6 +166,7 @@ const char *type_get_encoding (const type_t *type); int is_enum (const type_t *type) __attribute__((pure)); int is_integral (const type_t *type) __attribute__((pure)); int is_scalar (const type_t *type) __attribute__((pure)); +int is_nonscalar (const type_t *type) __attribute__((pure)); int is_math (const type_t *type) __attribute__((pure)); int is_struct (const type_t *type) __attribute__((pure)); int is_array (const type_t *type) __attribute__((pure)); diff --git a/tools/qfcc/source/class.c b/tools/qfcc/source/class.c index ce4499fdc..d90ecc062 100644 --- a/tools/qfcc/source/class.c +++ b/tools/qfcc/source/class.c @@ -71,33 +71,114 @@ static hashtab_t *static_instances; static hashtab_t *static_instance_classes; // these will be built up further -type_t type_selector = { ev_invalid, 0, 0, ty_struct}; -type_t type_SEL = { ev_ptr, "SEL", 1, ty_basic, {{&type_selector}}}; -type_t *IMP_params[] = {&type_id, &type_SEL}; -type_t type_IMP = { ev_func, "IMP", 1, ty_basic, - {{&type_id, -3, IMP_params}}}; -type_t type_super = { ev_invalid, 0, 0 }; -type_t type_SuperPtr = { ev_ptr, 0, 1, ty_basic, {{&type_super}}}; -type_t *supermsg_params[] = {&type_SuperPtr, &type_SEL}; -type_t type_supermsg = { ev_func, ".supermsg", 1, ty_basic, - {{&type_id, -3, supermsg_params}}}; -type_t type_method = { ev_invalid, 0, 0, ty_struct }; -type_t type_method_description = { ev_invalid, 0, 0, ty_struct }; -type_t type_category = { ev_invalid, 0, 0, ty_struct}; -type_t type_ivar = { ev_invalid, 0, 0, ty_struct}; -type_t type_module = { ev_invalid, 0, 0, ty_struct}; -type_t type_moduleptr = { ev_ptr, 0, 1, ty_basic, {{&type_module}}}; -type_t *obj_exec_class_params[] = { &type_moduleptr }; -type_t type_exec_class = { ev_func, 0, 1, ty_basic, - {{&type_void, 1, obj_exec_class_params}}}; +type_t type_selector = { + .type = ev_invalid, + .meta = ty_struct, +}; +type_t type_SEL = { + .type = ev_ptr, + .name = "SEL", + .alignment = 1, + .width = 1, + .meta = ty_basic, + {{&type_selector}}, +}; +type_t *IMP_params[] = { &type_id, &type_SEL }; +type_t type_IMP = { + .type = ev_func, + .name = "IMP", + .alignment = 1, + .width = 1, + .meta = ty_basic, + {{&type_id, -3, IMP_params}}, +}; +type_t type_super = { + .type = ev_invalid, +}; +type_t type_SuperPtr = { + .type = ev_ptr, + .alignment = 1, + .width = 1, + .meta = ty_basic, + {{&type_super}}, +}; +type_t *supermsg_params[] = { &type_SuperPtr, &type_SEL }; +type_t type_supermsg = { + .type = ev_func, + .name = ".supermsg", + .alignment = 1, + .width = 1, + .meta = ty_basic, + {{&type_id, -3, supermsg_params}}, +}; +type_t type_method = { + .type = ev_invalid, + .meta = ty_struct, +}; +type_t type_method_description = { + .type = ev_invalid, + .meta = ty_struct, +}; +type_t type_category = { + .type = ev_invalid, + .meta = ty_struct, +}; +type_t type_ivar = { + .type = ev_invalid, + .meta = ty_struct, +}; +type_t type_module = { + .type = ev_invalid, + .meta = ty_struct, +}; +type_t type_moduleptr = { + .type = ev_ptr, + .alignment = 1, + .width = 1, + .meta = ty_basic, + {{&type_module}}, +}; +type_t *obj_exec_class_params[] = { + &type_moduleptr, +}; +type_t type_exec_class = { + .type = ev_func, + .alignment = 1, + .width = 1, + .meta = ty_basic, + {{&type_void, 1, obj_exec_class_params}}, +}; // the cast of 1 in the init is to ensure pointers to incomplete types // are never misidentified as id. It will be set to the correct value // when the obj system is initialized. -type_t type_object = {ev_invalid, 0, 0, ty_struct, {{(type_t *)1}}}; -type_t type_id = { ev_ptr, "id", 1, ty_basic, {{&type_object}}}; -type_t type_class = { ev_invalid, 0, 0, ty_struct}; -type_t type_Class = { ev_ptr, 0, 1, ty_basic, {{&type_class}}}; -type_t type_protocol = { ev_invalid, 0, 0, ty_struct}; +type_t type_object = { + .type = ev_invalid, + .meta = ty_struct, + {{(type_t *)1}}, +}; +type_t type_id = { + .type = ev_ptr, + .name = "id", + .alignment = 1, + .width = 1, + .meta = ty_basic, + {{&type_object}}, +}; +type_t type_class = { + .type = ev_invalid, + .meta = ty_struct, +}; +type_t type_Class = { + .type = ev_ptr, + .alignment = 1, + .width = 1, + .meta = ty_basic, + {{&type_class}}, +}; +type_t type_protocol = { + .type = ev_invalid, + .meta = ty_struct, +}; int obj_initialized = 0; diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index aa4f79134..c85b68edf 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -185,6 +185,7 @@ parse_params (type_t *type, param_t *parms) new = new_type (); new->type = ev_func; new->alignment = 1; + new->width = 1; new->t.func.type = type; new->t.func.num_params = 0; diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index 51c7ce26d..79cc48943 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -230,12 +230,32 @@ v6p_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, return op; } +static etype_t +operand_type (operand_t *op) +{ + if (!op) { + return ev_invalid; + } + etype_t type = low_level_type (op->type); + if (type == ev_vector || type == ev_quaternion) { + return ev_float; + } + return type; +} + static int operand_width (operand_t *op) { if (!op) { return 0; } + etype_t type = low_level_type (op->type); + if (type == ev_vector) { + return 3; + } + if (type == ev_quaternion) { + return 4; + } return op->width; } @@ -246,9 +266,9 @@ rua_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, opcode_t search_op = { .opname = name, .types = { - op_a ? low_level_type (op_a->type) : ev_invalid, - op_b ? low_level_type (op_b->type) : ev_invalid, - op_c ? low_level_type (op_c->type) : ev_invalid, + operand_type (op_a), + operand_type (op_b), + operand_type (op_c), }, .widths = { operand_width (op_a), diff --git a/tools/qfcc/source/struct.c b/tools/qfcc/source/struct.c index 798696ac3..4a9f64bce 100644 --- a/tools/qfcc/source/struct.c +++ b/tools/qfcc/source/struct.c @@ -194,6 +194,8 @@ start_enum (symbol_t *sym) sym = find_enum (0); } sym->type->t.symtab = new_symtab (current_symtab, stab_local); + sym->type->alignment = 1; + sym->type->width = 1; return sym->type->t.symtab; } @@ -207,7 +209,6 @@ finish_enum (symbol_t *sym) enum_type = sym->type = find_type (sym->type); enum_tab = enum_type->t.symtab; - enum_type->alignment = 1; for (name = enum_tab->symbols; name; name = name->next) { name->type = sym->type; diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index ceb0360a5..94bf6aed0 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -65,6 +65,8 @@ .type = ev_##t, \ .name = #t, \ .alignment = PR_ALIGNOF(t), \ + .width = __builtin_choose_expr (ev_##t == ev_short \ + || ev_##t == ev_ushort, 0, 1), \ .meta = ty_basic, \ {{ __builtin_choose_expr (ev_##t == ev_field \ || ev_##t == ev_func \ @@ -72,7 +74,23 @@ }; #include "QF/progs/pr_type_names.h" -type_t type_invalid = { ev_invalid, "invalid" }; +type_t type_invalid = { + .type = ev_invalid, + .name = "invalid", +}; + +#define VTYPE(t, b) \ + type_t type_##t = { \ + .type = ev_##b, \ + .name = #t, \ + .alignment = PR_ALIGNOF(t), \ + .width = PR_SIZEOF(t) / PR_SIZEOF (b), \ + .meta = ty_basic, \ + }; +VTYPE(ivec3, int) +VTYPE(ivec4, int) +VTYPE(vec3, float) +VTYPE(vec4, float) type_t *type_nil; type_t *type_default; @@ -80,17 +98,49 @@ type_t *type_long_int; type_t *type_ulong_uint; // these will be built up further -type_t type_va_list = { ev_invalid, 0, 0, ty_struct }; -type_t type_param = { ev_invalid, 0, 0, ty_struct }; -type_t type_zero = { ev_invalid, 0, 0, ty_struct }; -type_t type_type_encodings = { ev_invalid, "@type_encodings", 0, - ty_struct }; -type_t type_xdef = { ev_invalid, "@xdef", 0, ty_struct }; -type_t type_xdef_pointer = { ev_ptr, 0, 1, ty_basic, {{&type_xdef}} }; -type_t type_xdefs = { ev_invalid, "@xdefs", 0, ty_struct }; +type_t type_va_list = { + .type = ev_invalid, + .meta = ty_struct, +}; +type_t type_param = { + .type = ev_invalid, + .meta = ty_struct, +}; +type_t type_zero = { + .type = ev_invalid, + .meta = ty_struct, +}; +type_t type_type_encodings = { + .type = ev_invalid, + .name = "@type_encodings", + .meta = ty_struct, +}; +type_t type_xdef = { + .type = ev_invalid, + .name = "@xdef", + .meta = ty_struct, +}; +type_t type_xdef_pointer = { + .type = ev_ptr, + .alignment = 1, + .width = 1, + .meta = ty_basic, + {{&type_xdef}}, +}; +type_t type_xdefs = { + .type = ev_invalid, + .name = "@xdefs", + .meta = ty_struct, +}; -type_t type_floatfield = { ev_field, ".float", 1, ty_basic, - {{&type_float}} }; +type_t type_floatfield = { + .type = ev_field, + .name = ".float", + .alignment = 1, + .width = 1, + .meta = ty_basic, + {{&type_float}}, +}; #define EV_TYPE(type) &type_##type, type_t *ev_types[ev_type_count] = { @@ -280,10 +330,12 @@ append_type (type_t *type, type_t *new) case ev_ptr: t = &(*t)->t.fldptr.type; type->alignment = 1; + type->width = 1; break; case ev_func: t = &(*t)->t.func.type; type->alignment = 1; + type->width = 1; break; case ev_invalid: internal_error (0, "invalid basic type"); @@ -293,6 +345,7 @@ append_type (type_t *type, type_t *new) case ty_array: t = &(*t)->t.array.type; type->alignment = new->alignment; + type->width = new->width; break; case ty_struct: case ty_union: @@ -339,7 +392,7 @@ types_same (type_t *a, type_t *b) return 0; return 1; default: // other types don't have aux data - return 1; + return a->width == b->width; } break; case ty_struct: @@ -447,6 +500,7 @@ field_type (type_t *aux) new = new_type (); new->type = ev_field; new->alignment = 1; + new->width = 1; if (aux) { new = find_type (append_type (new, aux)); } @@ -465,6 +519,7 @@ pointer_type (type_t *aux) new = new_type (); new->type = ev_ptr; new->alignment = 1; + new->width = 1; if (aux) { new = find_type (append_type (new, aux)); } @@ -485,6 +540,7 @@ array_type (type_t *aux, int size) new->type = ev_invalid; if (aux) { new->alignment = aux->alignment; + new->width = aux->width; } new->t.array.size = size; if (aux) { @@ -506,6 +562,7 @@ based_array_type (type_t *aux, int base, int top) new->type = ev_invalid; if (aux) { new->alignment = aux->alignment; + new->width = aux->width; } new->meta = ty_array; new->t.array.type = aux; @@ -523,6 +580,7 @@ alias_type (type_t *type, type_t *alias_chain, const char *name) alias->meta = ty_alias; alias->type = type->type; alias->alignment = type->alignment; + alias->width = type->width; if (type == alias_chain && type->meta == ty_alias) { // typedef of a type that contains a typedef somewhere // grab the alias-free branch for type @@ -868,6 +926,23 @@ int is_scalar (const type_t *type) { type = unalias_type (type); + if (is_short (type) || is_ushort (type)) { + // shorts have width 0 + return 1; + } + if (type->width != 1) { + return 0; + } + return is_float (type) || is_integral (type) || is_double (type); +} + +int +is_nonscalar (const type_t *type) +{ + type = unalias_type (type); + if (type->width < 2) { + return 0; + } return is_float (type) || is_integral (type) || is_double (type); } @@ -875,9 +950,11 @@ int is_math (const type_t *type) { type = unalias_type (type); - etype_t t = type->type; - return t == ev_vector || t == ev_quaternion || is_scalar (type); + if (is_vector (type) || is_quaternion (type)) { + return 1; + } + return is_scalar (type) || is_nonscalar (type); } int @@ -981,7 +1058,7 @@ type_size (const type_t *type) { switch (type->meta) { case ty_basic: - return pr_type_size[type->type]; + return pr_type_size[type->type] * type->width; case ty_struct: case ty_union: if (!type->t.symtab) @@ -1015,10 +1092,13 @@ type_width (const type_t *type) { switch (type->meta) { case ty_basic: - if (type->type == ev_ushort || type->type == ev_short) { - return 0; + if (type->type == ev_vector) { + return 3; } - return 1; //FIXME vector should be 3 + if (type->type == ev_quaternion) { + return 4; + } + return type->width; case ty_struct: case ty_union: return 1; @@ -1050,11 +1130,21 @@ chain_basic_types (void) chain_type (&type_ptr); chain_type (&type_floatfield); if (!options.traditional) { + if (options.code.progsversion == PROG_VERSION) { + type_quaternion.alignment = 4; + } chain_type (&type_quaternion); chain_type (&type_int); chain_type (&type_uint); chain_type (&type_short); chain_type (&type_double); + + if (options.code.progsversion == PROG_VERSION) { + chain_type (&type_ivec3); + chain_type (&type_ivec4); + chain_type (&type_vec3); + chain_type (&type_vec4); + } } } From 3f389b602a4b987dfb2b8b68f26be323c7f3e919 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 10:56:15 +0900 Subject: [PATCH 264/360] [qfcc] Add support for horizontal vector ops And reimplement vector comparison for Ruamoko. --- tools/qfcc/include/expr.h | 24 ++++++++++++-- tools/qfcc/include/expr_names.h | 1 + tools/qfcc/source/expr.c | 34 ++++++++++++++++++++ tools/qfcc/source/expr_assign.c | 1 + tools/qfcc/source/expr_binary.c | 21 +++++++++++-- tools/qfcc/source/qc-parse.y | 1 + tools/qfcc/source/qp-parse.y | 1 + tools/qfcc/source/statements.c | 56 ++++++++++++++++++++++++++++++++- 8 files changed, 134 insertions(+), 5 deletions(-) diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index f2b934324..5181dfbc6 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -249,6 +249,12 @@ typedef struct { struct expr_s *with; ///< value to load } ex_with_t; +typedef struct { + int op; ///< operation to perform + struct expr_s *vec; ///< vector expression on which to operate + struct type_s *type; ///< result type +} ex_horizontal_t; + #define POINTER_VAL(p) (((p).def ? (p).def->offset : 0) + (p).val) typedef struct expr_s { @@ -283,6 +289,7 @@ typedef struct expr_s { ex_adjstk_t adjstk; ///< stack adjust param ex_with_t with; ///< with expr param struct type_s *nil; ///< type for nil if known + ex_horizontal_t hop; ///< horizontal vector operation } e; } expr_t; @@ -432,7 +439,7 @@ void build_element_chain (element_chain_t *element_chain, expr_t *eles, int base_offset); void free_element_chain (element_chain_t *element_chain); -/** Create a new binary expression node node. +/** Create a new binary expression node. If either \a e1 or \a e2 are error expressions, then that expression will be returned instead of a new binary expression. @@ -446,7 +453,7 @@ void free_element_chain (element_chain_t *element_chain); */ expr_t *new_binary_expr (int op, expr_t *e1, expr_t *e2); -/** Create a new unary expression node node. +/** Create a new unary expression node. If \a e1 is an error expression, then it will be returned instead of a new unary expression. @@ -458,6 +465,19 @@ expr_t *new_binary_expr (int op, expr_t *e1, expr_t *e2); */ expr_t *new_unary_expr (int op, expr_t *e1); +/** Create a new horizontal vector operantion node. + + If \a vec is an error expression, then it will be returned instead of a + new unary expression. + + \param op The op-code of the horizontal operation. + \param vec The expression (must be a vector type) on which to operate. + \param type The result type (must be scalar type) + \return The new unary expression node (::ex_expr_t) if \a e1 + is not an error expression, otherwise \a e1. +*/ +expr_t *new_horizontal_expr (int op, expr_t *vec, struct type_s *type); + /** Create a new def reference (non-temporary variable) expression node. \return The new def reference expression node (::def_t). diff --git a/tools/qfcc/include/expr_names.h b/tools/qfcc/include/expr_names.h index 820ba9826..05d1f197a 100644 --- a/tools/qfcc/include/expr_names.h +++ b/tools/qfcc/include/expr_names.h @@ -62,5 +62,6 @@ EX_EXPR(return) ///< return expression (::ex_return_t) EX_EXPR(adjstk) ///< stack adjust expression (::ex_adjstk_t) EX_EXPR(with) ///< with expression (::ex_with_t) EX_EXPR(args) ///< @args marker in parameter list. no data +EX_EXPR(horizontal) ///< horizontal vector operation (::ex_horzontal_t) ///@} diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 66140bc52..7af72d5a1 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -276,6 +276,8 @@ get_type (expr_t *e) return get_type (e->e.assign.dst); case ex_args: return &type_va_list; + case ex_horizontal: + return e->e.hop.type; case ex_count: internal_error (e, "invalid expression"); } @@ -531,6 +533,11 @@ copy_expr (expr_t *e) n = new_expr (); *n = *e; return n; + case ex_horizontal: + n = new_expr (); + *n = *e; + e->e.hop.vec = copy_expr (e->e.hop.vec); + return n; case ex_count: break; } @@ -695,6 +702,28 @@ new_unary_expr (int op, expr_t *e1) return e; } +expr_t * +new_horizontal_expr (int op, expr_t *vec, type_t *type) +{ + type_t *vec_type = get_type (vec); + if (!vec_type) { + return vec; + } + if (!is_math (vec_type) || is_scalar (vec_type)) { + internal_error (vec, "horizontal operand not a vector type"); + } + if (!is_scalar (type)) { + internal_error (vec, "horizontal result not a scalar type"); + } + + expr_t *e = new_expr (); + e->type = ex_horizontal; + e->e.hop.op = op; + e->e.hop.vec = vec; + e->e.hop.type = type; + return e; +} + expr_t * new_def_expr (def_t *def) { @@ -1733,6 +1762,8 @@ has_function_call (expr_t *e) return has_function_call (e->e.branch.test); case ex_return: return has_function_call (e->e.retrn.ret_val); + case ex_horizontal: + return has_function_call (e->e.hop.vec); case ex_error: case ex_state: case ex_label: @@ -1873,6 +1904,7 @@ unary_expr (int op, expr_t *e) case ex_vector: case ex_alias: case ex_assign: + case ex_horizontal: { expr_t *n = new_unary_expr (op, e); @@ -1965,6 +1997,7 @@ unary_expr (int op, expr_t *e) case ex_alias: case ex_address: case ex_assign: + case ex_horizontal: if (options.code.progsversion == PROG_VERSION) { return binary_expr (EQ, e, new_nil_expr ()); } else { @@ -2053,6 +2086,7 @@ unary_expr (int op, expr_t *e) case ex_vector: case ex_alias: case ex_assign: + case ex_horizontal: bitnot_expr: if (options.code.progsversion == PROG_ID_VERSION) { expr_t *n1 = new_int_expr (-1); diff --git a/tools/qfcc/source/expr_assign.c b/tools/qfcc/source/expr_assign.c index f9a66b1be..e193de6aa 100644 --- a/tools/qfcc/source/expr_assign.c +++ b/tools/qfcc/source/expr_assign.c @@ -141,6 +141,7 @@ is_lvalue (const expr_t *expr) case ex_adjstk: case ex_with: case ex_args: + case ex_horizontal: break; case ex_count: internal_error (expr, "invalid expression"); diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index c2acf4028..f533b38cd 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -51,6 +51,7 @@ static expr_t *pointer_compare (int op, expr_t *e1, expr_t *e2); static expr_t *func_compare (int op, expr_t *e1, expr_t *e2); static expr_t *inverse_multiply (int op, expr_t *e1, expr_t *e2); static expr_t *double_compare (int op, expr_t *e1, expr_t *e2); +static expr_t *vector_compare (int op, expr_t *e1, expr_t *e2); static expr_type_t string_string[] = { {'+', &type_string}, @@ -145,8 +146,8 @@ static expr_type_t vector_vector[] = { {'+', &type_vector}, {'-', &type_vector}, {'*', &type_float}, - {EQ, &type_int}, - {NE, &type_int}, + {EQ, 0, 0, 0, vector_compare}, + {NE, 0, 0, 0, vector_compare}, {0, 0} }; @@ -721,6 +722,22 @@ inverse_multiply (int op, expr_t *e1, expr_t *e2) return binary_expr ('*', e1, binary_expr ('/', one, e2)); } +static expr_t * +vector_compare (int op, expr_t *e1, expr_t *e2) +{ + if (options.code.progsversion < PROG_VERSION) { + expr_t *e = new_binary_expr (op, e1, e2); + e->e.expr.type = &type_int; + return e; + } + int hop = op == EQ ? '&' : '|'; + e1 = new_alias_expr (&type_vec3, e1); + e2 = new_alias_expr (&type_vec3, e2); + expr_t *e = new_binary_expr (op, e1, e2); + e->e.expr.type = &type_ivec3; + return new_horizontal_expr (hop, e, &type_int); +} + static expr_t * double_compare (int op, expr_t *e1, expr_t *e2) { diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index 282f501ae..0e23c1eb2 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -133,6 +133,7 @@ int yylex (void); %left '&' %left EQ NE %left LT GT GE LE +%token NAND NOR XNOR // end of tokens common between qc and qp %left SHL SHR diff --git a/tools/qfcc/source/qp-parse.y b/tools/qfcc/source/qp-parse.y index db0274ce4..550f8e3f8 100644 --- a/tools/qfcc/source/qp-parse.y +++ b/tools/qfcc/source/qp-parse.y @@ -114,6 +114,7 @@ int yylex (void); %left '&' %left EQ NE %left LT GT GE LE +%token NAND NOR XNOR // end of tokens common between qc and qp %left RELOP diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 2ade73a9f..3de08e449 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1666,6 +1666,59 @@ expr_uexpr (sblock_t *sblock, expr_t *e, operand_t **op) return sblock; } +static sblock_t * +expr_horizontal (sblock_t *sblock, expr_t *e, operand_t **op) +{ + const char *opcode = "hops"; + statement_t *s; + int hop; + type_t *res_type = e->e.hop.type; + type_t *vec_type = get_type (e->e.hop.vec); + + switch (e->e.hop.op) { + case '&': + hop = 0; + break; + case '|': + hop = 1; + break; + case '^': + hop = 2; + break; + case '+': + if (is_integral (vec_type)) { + hop = 3; + } else { + hop = 7; + } + break; + case NAND: + hop = 4; + break; + case NOR: + hop = 5; + break; + case XNOR: + hop = 6; + break; + default: + internal_error (e, "invalid horizontal op"); + } + hop |= (type_width (vec_type) - 1) << 3; + hop |= (pr_type_size[vec_type->type] - 1) << 5; + + s = new_statement (st_expr, opcode, e); + sblock = statement_subexpr (sblock, e->e.hop.vec, &s->opa); + s->opb = short_operand (hop, e); + if (!*op) { + *op = temp_operand (res_type, e); + } + s->opc = *op; + sblock_add_statement (sblock, s); + + return sblock; +} + static sblock_t * expr_def (sblock_t *sblock, expr_t *e, operand_t **op) { @@ -1826,6 +1879,7 @@ statement_subexpr (sblock_t *sblock, expr_t *e, operand_t **op) [ex_block] = expr_block, [ex_expr] = expr_expr, [ex_uexpr] = expr_uexpr, + [ex_horizontal] = expr_horizontal, [ex_def] = expr_def, [ex_symbol] = expr_symbol, [ex_temp] = expr_temp, @@ -1844,7 +1898,7 @@ statement_subexpr (sblock_t *sblock, expr_t *e, operand_t **op) } if (e->type >= ex_count) - internal_error (e, "bad sub-expression type"); + internal_error (e, "bad sub-expression type: %d", e->type); if (!sfuncs[e->type]) internal_error (e, "unexpected sub-expression type: %s", expr_names[e->type]); From 218481764b5817f623bb17a22532a5ba46654228 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 13:57:41 +0900 Subject: [PATCH 265/360] [qfcc] Add failing test for temp.component While it specifically checks vectors, I'm pretty sure it applies to structs, too. Also, it's a little redundant with vecaddr.r, but is much more specific and far less evil in what it does (no horrible pointer shenanigans): just something that is fairly common practice. --- tools/qfcc/test/Makemodule.am | 11 +++++++++++ tools/qfcc/test/temp-component.r | 13 +++++++++++++ 2 files changed, 24 insertions(+) create mode 100644 tools/qfcc/test/temp-component.r diff --git a/tools/qfcc/test/Makemodule.am b/tools/qfcc/test/Makemodule.am index acfa99873..eaa3d673c 100644 --- a/tools/qfcc/test/Makemodule.am +++ b/tools/qfcc/test/Makemodule.am @@ -54,6 +54,7 @@ test_progs_dat=\ tools/qfcc/test/structptr.dat \ tools/qfcc/test/structstruct.dat \ tools/qfcc/test/swap.dat \ + tools/qfcc/test/temp-component.dat \ tools/qfcc/test/triangle.dat \ tools/qfcc/test/twice-called.dat \ tools/qfcc/test/typedef.dat \ @@ -618,6 +619,16 @@ tools/qfcc/test/swap.run: $(qfcc_test_run_deps) include $(swap_dep) # am--include-marker r_depfiles_remade += $(swap_dep) +tools_qfcc_test_temp_component_dat_SOURCES=tools/qfcc/test/temp-component.r +temp_component_obj=$(tools_qfcc_test_temp_component_dat_SOURCES:.r=.o) +temp_component_dep=$(call qcautodep,$(tools_qfcc_test_temp_component_dat_SOURCES)) +tools/qfcc/test/temp-component.dat$(EXEEXT): $(temp_component_obj) $(QFCC_DEP) + $(V_QFCCLD)$(QLINK) -o $@ $(temp_component_obj) +tools/qfcc/test/temp-component.run: $(qfcc_test_run_deps) + @$(top_srcdir)/tools/qfcc/test/build-run $@ +include $(temp_component_dep) # am--include-marker +r_depfiles_remade += $(temp_component_dep) + tools_qfcc_test_triangle_dat_SOURCES=tools/qfcc/test/triangle.r triangle_obj=$(tools_qfcc_test_triangle_dat_SOURCES:.r=.o) triangle_dep=$(call qcautodep,$(tools_qfcc_test_triangle_dat_SOURCES)) diff --git a/tools/qfcc/test/temp-component.r b/tools/qfcc/test/temp-component.r new file mode 100644 index 000000000..2db18a401 --- /dev/null +++ b/tools/qfcc/test/temp-component.r @@ -0,0 +1,13 @@ +float +gety(vector v, vector z) +{ + return (v + z).y; +} + +int +main () +{ + vector a = [1, 2, 3]; + vector b = [1, 2, 6]; + return gety (a, b) != 4; +} From e195dba6264682c0aac7ff31776c3413df855f8a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 14:02:13 +0900 Subject: [PATCH 266/360] [qfcc] Do not unalias temporary operands I don't remember why I did this originally, but it causes the dags code to lose the offset temp alias when accessing fields on structural temps (known to be the case for vectors (temp-component.r), and I seem to remember having problems with structs). --- tools/qfcc/source/dags.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/tools/qfcc/source/dags.c b/tools/qfcc/source/dags.c index ac3a36a63..7a52a4f6b 100644 --- a/tools/qfcc/source/dags.c +++ b/tools/qfcc/source/dags.c @@ -231,8 +231,6 @@ dag_node (operand_t *op) if (def->daglabel) node = def->daglabel->dagnode; } else if (op->op_type == op_temp) { - while (op->tempop.alias) - op = op->tempop.alias; if (op->tempop.daglabel) node = op->tempop.daglabel->dagnode; } else if (op->op_type == op_value) { From 46ce37160bb38d42cd77f6aef05dc6295ec48a25 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 14:11:41 +0900 Subject: [PATCH 267/360] [gamecode] Correct vecops widths I had forgotten to update the widths when I moved cross product's position. --- libs/gamecode/opcodes.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index d2da04ed7..61e65f136 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -478,10 +478,10 @@ vecops_formats = { "cmul", "qvmul", "vqmul", "qmul"], "vop_type": ['F', 'D'], "vec_widths": [ + "3, 3, 3", "2, 2, 2", "3, 3, 3", "4, 4, 4", - "3, 3, 3", "2, 2, 2", "4, 3, 3", "3, 4, 3", From d8f6a9445e5874271ccf21a708cf691878301d3a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 14:14:15 +0900 Subject: [PATCH 268/360] [qfcc] Implement dot and cross product for Ruamoko With explicit operators, even. While they're a tad verbose, they're at least unambiguous and most importantly have the right precedence (or at least adjustable precedence if I got it wrong, but vector ops having high precedence than scalar or component seems reasonable to me). --- tools/qfcc/source/dot_expr.c | 2 ++ tools/qfcc/source/expr_binary.c | 19 ++++++++++++++++++- tools/qfcc/source/qc-lex.l | 3 +++ tools/qfcc/source/qc-parse.y | 3 +++ tools/qfcc/source/statements.c | 10 ++++++++++ 5 files changed, 36 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index e5b5e87ea..04784856a 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -90,6 +90,8 @@ get_op_string (int op) case SHR: return ">>"; case '.': return "."; case 'C': return ""; + case CROSS: return "@cross"; + case DOT: return "@dot"; default: return "unknown"; } diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index f533b38cd..47dc3ae5c 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -52,6 +52,7 @@ static expr_t *func_compare (int op, expr_t *e1, expr_t *e2); static expr_t *inverse_multiply (int op, expr_t *e1, expr_t *e2); static expr_t *double_compare (int op, expr_t *e1, expr_t *e2); static expr_t *vector_compare (int op, expr_t *e1, expr_t *e2); +static expr_t *vector_multiply (int op, expr_t *e1, expr_t *e2); static expr_type_t string_string[] = { {'+', &type_string}, @@ -145,7 +146,9 @@ static expr_type_t vector_float[] = { static expr_type_t vector_vector[] = { {'+', &type_vector}, {'-', &type_vector}, - {'*', &type_float}, + {DOT, &type_vector}, + {CROSS, &type_vector}, + {'*', 0, 0, 0, vector_multiply}, {EQ, 0, 0, 0, vector_compare}, {NE, 0, 0, 0, vector_compare}, {0, 0} @@ -738,6 +741,20 @@ vector_compare (int op, expr_t *e1, expr_t *e2) return new_horizontal_expr (hop, e, &type_int); } +static expr_t *vector_multiply (int op, expr_t *e1, expr_t *e2) +{ + expr_t *e = new_binary_expr ('*', e1, e2); + if (options.code.progsversion < PROG_VERSION) { + // vector * vector is dot product in v6 progs (ick) + e->e.expr.type = &type_float; + } else { + // component-wise multiplication + e->e.expr.type = &type_vector; + } + + return e; +} + static expr_t * double_compare (int op, expr_t *e1, expr_t *e2) { diff --git a/tools/qfcc/source/qc-lex.l b/tools/qfcc/source/qc-lex.l index 7ce445539..c2db6db0c 100644 --- a/tools/qfcc/source/qc-lex.l +++ b/tools/qfcc/source/qc-lex.l @@ -386,6 +386,9 @@ static keyword_t qf_keywords[] = { {"@args", ARGS, 0 }, {"@va_list", TYPE, &type_va_list }, {"@param", TYPE, &type_param }, + + {"@cross", CROSS, 0 }, + {"@dot", DOT, 0 }, }; // These keywors are always available. Other than @system and @overload, they diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index 0e23c1eb2..7d294db13 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -139,6 +139,7 @@ int yylex (void); %left SHL SHR %left '+' '-' %left '*' '/' '%' MOD +%left CROSS DOT %right SIZEOF UNARY INCOP %left HYPERUNARY %left '.' '(' '[' @@ -1621,6 +1622,8 @@ expr | expr '^' expr { $$ = binary_expr ('^', $1, $3); } | expr '%' expr { $$ = binary_expr ('%', $1, $3); } | expr MOD expr { $$ = binary_expr (MOD, $1, $3); } + | expr CROSS expr { $$ = binary_expr (CROSS, $1, $3); } + | expr DOT expr { $$ = binary_expr (DOT, $1, $3); } ; texpr diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 3de08e449..bce46f8cd 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -604,6 +604,8 @@ convert_op (int op) case SHL: return "shl"; case SHR: return "shr"; case '.': return "load"; + case CROSS: return "cross"; + case DOT: return "dot"; default: return 0; } @@ -1568,6 +1570,14 @@ expr_expr (sblock_t *sblock, expr_t *e, operand_t **op) if (strcmp (opcode, "ne") == 0 && is_string (get_type (e->e.expr.e1))) { opcode = "cmp"; } + if (strcmp (opcode, "dot") == 0) { + if (is_vector (get_type (e->e.expr.e1))) { + opcode = "vdot"; + } + if (is_quaternion (get_type (e->e.expr.e1))) { + opcode = "qdot"; + } + } s = new_statement (st_expr, opcode, e); sblock = statement_subexpr (sblock, e->e.expr.e1, &s->opa); sblock = statement_subexpr (sblock, e->e.expr.e2, &s->opb); From 09eef8a07bc5ae2b2651a6d2bf2be2dc7187fa08 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 14:21:07 +0900 Subject: [PATCH 269/360] [qfcc] Define __RUAMOKO__ as 2 for Ruamoko ISA and __RAUMOKO__ as well. --- tools/qfcc/source/options.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/tools/qfcc/source/options.c b/tools/qfcc/source/options.c index 7283ba9f7..573730986 100644 --- a/tools/qfcc/source/options.c +++ b/tools/qfcc/source/options.c @@ -713,8 +713,13 @@ DecodeArgs (int argc, char **argv) options.code.progsversion = PROG_V6P_VERSION; if (!options.traditional) { options.advanced = true; - add_cpp_def ("-D__RUAMOKO__=1"); - add_cpp_def ("-D__RAUMOKO__=1"); + if (options.code.progsversion < PROG_VERSION) { + add_cpp_def ("-D__RUAMOKO__=1"); + add_cpp_def ("-D__RAUMOKO__=1"); + } else { + add_cpp_def ("-D__RUAMOKO__=2"); + add_cpp_def ("-D__RAUMOKO__=2"); + } if (options.code.ifstring == (qboolean) -1) options.code.ifstring = false; if (options.code.short_circuit == (qboolean) -1) From d18ee8dd86a77fb98f1be2ce12efa8fdb8c81041 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 14:17:52 +0900 Subject: [PATCH 270/360] [qfcc] Make vecaddr work in both v6p and Ruamoko It's full of evil hacks, but has always been an evil hack relying on undefined behavior. The weird shenanigans with local variables are because Ruamoko doesn't copy the parameters like v6p does and thus v and z are NOT adjacent as parameters. Worse, the padding is uninitialized and thus should not be relied upon to be any particular value. Still does a nice job of testing dot products, though. --- tools/qfcc/test/vecaddr.r | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-) diff --git a/tools/qfcc/test/vecaddr.r b/tools/qfcc/test/vecaddr.r index 323d9205c..6bd407d9b 100644 --- a/tools/qfcc/test/vecaddr.r +++ b/tools/qfcc/test/vecaddr.r @@ -1,8 +1,25 @@ void printf (string fmt, ...) = #0; -float foo (vector v, float z) +#if __RUAMOKO__ > 1 +#define dot @dot +#define X .y +#else +#define dot * +#define X +#endif + +void forcelive (float z) { - return v * *(vector*)(&v.y); +} + +float foo (vector _v, float _z) +{ + vector v = _v; + float z = _z; + _v = nil; + _z = _z - _z; + forcelive (z); + return (v dot *(vector*)(&v.y))X; } int @@ -11,6 +28,6 @@ main (int argc, string *argv) vector v = [1, 2, 3]; vector w = [2, 3, 4]; float f; - printf ("%v %g %g %g\n", v, v*v, v*w, f=foo (v, 4)); - return f != v*w; + printf ("%v %g %g %g\n", v, v dot v, v dot w, f=foo (v, 4)); + return f != (v dot w)X; } From 4871717faec50611f9ebdcae2e2ba31075c8b485 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 14:47:26 +0900 Subject: [PATCH 271/360] [gamecode] Rename v6 vector-scalar multiply to scale Makes it easier to get Ruamoko scaling implemented if they both use the same opname. --- libs/gamecode/pr_v6p_opcode.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index c99ef1580..a76dfe06e 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -89,11 +89,11 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { ev_vector, ev_vector, ev_float, PROG_ID_VERSION, }, - [OP_MUL_FV_v6p] = {"mul", "mul.fv", + [OP_MUL_FV_v6p] = {"scale", "mul.fv", ev_float, ev_vector, ev_vector, PROG_ID_VERSION, }, - [OP_MUL_VF_v6p] = {"mul", "mul.vf", + [OP_MUL_VF_v6p] = {"scale", "mul.vf", ev_vector, ev_float, ev_vector, PROG_ID_VERSION, }, From 4b8fdf36968adbd50d61e3abae867238bb94d57b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 14:48:49 +0900 Subject: [PATCH 272/360] [qfcc] Implement vector scaling for Ruamoko With this, qfcc-tests builds (can't run yet due to unsigned not having any tests and thus the rest the Ruamoko code in QF not building yet). --- tools/qfcc/source/constfold.c | 4 ++-- tools/qfcc/source/expr_binary.c | 20 ++++++++++++++++++-- tools/qfcc/source/qc-parse.y | 2 +- tools/qfcc/source/statements.c | 1 + 4 files changed, 22 insertions(+), 5 deletions(-) diff --git a/tools/qfcc/source/constfold.c b/tools/qfcc/source/constfold.c index ae36079b3..6b01bc7f4 100644 --- a/tools/qfcc/source/constfold.c +++ b/tools/qfcc/source/constfold.c @@ -446,7 +446,7 @@ do_op_vector (int op, expr_t *e, expr_t *e1, expr_t *e2) { const float *v1, *v2; vec3_t v, float_vec; - static int valid[] = {'+', '-', '*', EQ, NE, 0}; + static int valid[] = {'+', '-', '*', SCALE, EQ, NE, 0}; expr_t *t; if (!is_vector(get_type (e1))) { @@ -460,7 +460,7 @@ do_op_vector (int op, expr_t *e, expr_t *e1, expr_t *e2) } if (!is_vector(get_type (e2))) { e->e.expr.e2 = e2 = convert_to_float (e2); - if (op != '*' && op != '/') + if (op != SCALE && op != '/') return error (e1, "invalid operator for vector"); } else { if (!valid_op (op, valid)) diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index 47dc3ae5c..5bd004d42 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -53,6 +53,7 @@ static expr_t *inverse_multiply (int op, expr_t *e1, expr_t *e2); static expr_t *double_compare (int op, expr_t *e1, expr_t *e2); static expr_t *vector_compare (int op, expr_t *e1, expr_t *e2); static expr_t *vector_multiply (int op, expr_t *e1, expr_t *e2); +static expr_t *vector_scale (int op, expr_t *e1, expr_t *e2); static expr_type_t string_string[] = { {'+', &type_string}, @@ -89,7 +90,7 @@ static expr_type_t float_float[] = { }; static expr_type_t float_vector[] = { - {'*', &type_vector}, + {'*', .process = vector_scale }, {0, 0} }; @@ -138,7 +139,7 @@ static expr_type_t float_double[] = { }; static expr_type_t vector_float[] = { - {'*', &type_vector}, + {'*', .process = vector_scale }, {'/', 0, 0, 0, inverse_multiply}, {0, 0} }; @@ -755,6 +756,21 @@ static expr_t *vector_multiply (int op, expr_t *e1, expr_t *e2) return e; } +static expr_t *vector_scale (int op, expr_t *e1, expr_t *e2) +{ + // Ensure the expression is always vector * scalar. The operation is + // always commutative, and the Ruamoko ISA supports only vector * scalar + // (though v6 does support scalar * vector, one less if). + if (is_scalar (get_type (e1))) { + expr_t *t = e1; + e1 = e2; + e2 = t; + } + expr_t *e = new_binary_expr (SCALE, e1, e2); + e->e.expr.type = get_type (e1); + return e; +} + static expr_t * double_compare (int op, expr_t *e1, expr_t *e2) { diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index 7d294db13..3ab14cbe2 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -138,7 +138,7 @@ int yylex (void); %left SHL SHR %left '+' '-' -%left '*' '/' '%' MOD +%left '*' '/' '%' MOD SCALE %left CROSS DOT %right SIZEOF UNARY INCOP %left HYPERUNARY diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index bce46f8cd..e9b375aba 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -606,6 +606,7 @@ convert_op (int op) case '.': return "load"; case CROSS: return "cross"; case DOT: return "dot"; + case SCALE: return "scale"; default: return 0; } From e1a0c31e3f5ba832f8787bcd4048d1551fce84d7 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 16:00:49 +0900 Subject: [PATCH 273/360] [qfcc] Encode the new vector types Thanks to the size of the type encoding being explicit in the encoding, anything that tries to read the encodings without expecting the width will simply skip over the width, as it is placed after the ev type in the encoding. Any code that needs to read both the old encodings and the new can check the size of the basic encodings to see if the width field is present. --- include/QF/progs/pr_type.h | 7 +++++++ tools/qfcc/source/dump_globals.c | 9 ++++++++ tools/qfcc/source/obj_type.c | 5 +++-- tools/qfcc/source/type.c | 36 ++++++++++++++++++++++++++------ 4 files changed, 49 insertions(+), 8 deletions(-) diff --git a/include/QF/progs/pr_type.h b/include/QF/progs/pr_type.h index 02c591dfa..7f117e7a3 100644 --- a/include/QF/progs/pr_type.h +++ b/include/QF/progs/pr_type.h @@ -62,6 +62,12 @@ typedef struct qfot_fldptr_s { pr_ptr_t aux_type; ///< referenced type } qfot_fldptr_t; +typedef struct qfot_basic_s { + etype_t type; ///< integral and fp scalar types + pr_int_t width; ///< components in vector (1 for vector or + ///< quaternion) +} qfot_basic_t; + typedef struct qfot_func_s { etype_t type; ///< always ev_func pr_ptr_t return_type; ///< return type of the function @@ -106,6 +112,7 @@ typedef struct qfot_type_s { pr_string_t encoding; ///< Objective-QC encoding union { etype_t type; ///< ty_basic: etype_t + qfot_basic_t basic; ///< ty_basic: int/float/double/long etc qfot_fldptr_t fldptr; ///< ty_basic, ev_ptr/ev_field qfot_func_t func; ///< ty_basic, ev_func qfot_struct_t strct; ///< ty_struct/ty_union/ty_enum diff --git a/tools/qfcc/source/dump_globals.c b/tools/qfcc/source/dump_globals.c index 3f1b412cd..c0ade919b 100644 --- a/tools/qfcc/source/dump_globals.c +++ b/tools/qfcc/source/dump_globals.c @@ -513,6 +513,12 @@ static const char *ty_meta_names[] = { "ty_alias", }; #define NUM_META ((int)(sizeof (ty_meta_names) / sizeof (ty_meta_names[0]))) +const int vector_types = (1 << ev_float) + | (1 << ev_int) + | (1 << ev_uint) + | (1 << ev_double) + | (1 << ev_long) + | (1 << ev_ulong); static void dump_qfo_types (qfo_t *qfo, int base_address) @@ -563,6 +569,9 @@ dump_qfo_types (qfo_t *qfo, int base_address) } else if (type->type == ev_ptr || type->type == ev_field) { printf (" %4x", type->fldptr.aux_type); + } else if ((1 << type->type) & vector_types + && type->basic.width > 1) { + printf ("[%d]", type->basic.width); } printf ("\n"); break; diff --git a/tools/qfcc/source/obj_type.c b/tools/qfcc/source/obj_type.c index 8d1f5cacf..c00f2f43e 100644 --- a/tools/qfcc/source/obj_type.c +++ b/tools/qfcc/source/obj_type.c @@ -152,9 +152,10 @@ qfo_encode_basic (type_t *type, defspace_t *space) else if (type->type == ev_ptr || type->type == ev_field) return qfo_encode_fldptr (type, space); - def = qfo_new_encoding (type, sizeof (enc->type), space); + def = qfo_new_encoding (type, sizeof (enc->basic), space); enc = D_POINTER (qfot_type_t, def); - enc->type = type->type; + enc->basic.type = type->type; + enc->basic.width = type->width; return def; } diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index 94bf6aed0..7e73fc99d 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -829,10 +829,18 @@ encode_type (dstring_t *encoding, const type_t *type) dasprintf (encoding, "*"); return; case ev_double: - dasprintf (encoding, "d"); + if (type->width > 1) { + dasprintf (encoding, "d%d", type->width); + } else { + dasprintf (encoding, "d"); + } return; case ev_float: - dasprintf (encoding, "f"); + if (type->width > 1) { + dasprintf (encoding, "f%d", type->width); + } else { + dasprintf (encoding, "f"); + } return; case ev_vector: dasprintf (encoding, "V"); @@ -870,16 +878,32 @@ encode_type (dstring_t *encoding, const type_t *type) dasprintf (encoding, "Q"); return; case ev_int: - dasprintf (encoding, "i"); + if (type->width > 1) { + dasprintf (encoding, "i%d", type->width); + } else { + dasprintf (encoding, "i"); + } return; case ev_uint: - dasprintf (encoding, "I"); + if (type->width > 1) { + dasprintf (encoding, "I%d", type->width); + } else { + dasprintf (encoding, "I"); + } return; case ev_long: - dasprintf (encoding, "l"); + if (type->width > 1) { + dasprintf (encoding, "l%d", type->width); + } else { + dasprintf (encoding, "l"); + } return; case ev_ulong: - dasprintf (encoding, "L"); + if (type->width > 1) { + dasprintf (encoding, "L%d", type->width); + } else { + dasprintf (encoding, "L"); + } return; case ev_short: dasprintf (encoding, "s"); From b8df11b2cbedab8499e47f44c3922820456a531f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 20:01:32 +0900 Subject: [PATCH 274/360] [qfcc] Really get vecaddr.r working on both ISAs Deliberately defeating an optimiser is not so easy (but I really needed that variable to be set). --- tools/qfcc/test/vecaddr.r | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/test/vecaddr.r b/tools/qfcc/test/vecaddr.r index 6bd407d9b..965fbf716 100644 --- a/tools/qfcc/test/vecaddr.r +++ b/tools/qfcc/test/vecaddr.r @@ -17,7 +17,8 @@ float foo (vector _v, float _z) vector v = _v; float z = _z; _v = nil; - _z = _z - _z; + _z = 0; + forcelive (_z); forcelive (z); return (v dot *(vector*)(&v.y))X; } From 766bf758ab557daeaf5a5d51c7bee2d01bcda64d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 22:34:40 +0900 Subject: [PATCH 275/360] [gamecode] Redesign jump's B addressing Yet another redundant addressing mode (since ptr + 0 can be used), so replace it with a variable-indexed array (same as in v6p). Was forced into noticing the problem when trying to compile Machine.r. --- libs/gamecode/opcodes.py | 4 ++-- libs/gamecode/pr_exec.c | 4 ++-- libs/gamecode/test/test-jump.c | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 61e65f136..a07714d88 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -204,11 +204,11 @@ jump_formats = { "jump_fmt": branch_fmt, "jump_types": [ "ev_short, ev_invalid, ev_invalid", - "ev_ptr, ev_invalid, ev_invalid", + "ev_void, ev_int, ev_invalid", "ev_ptr, ev_short, ev_invalid", "ev_ptr, ev_int, ev_invalid", ], - "jump_widths": [ "0, 0", "1, 0", "1, 0", "1, 1" ] + "jump_widths": [ "0, 0", "1, 1", "1, 0", "1, 1" ] }, } lea_formats = { diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 9801d9936..15c63d0a4 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1867,8 +1867,8 @@ pr_jump_mode (progs_t *pr, const dstatement_t *st, int jump_ind) jump_offs = jump_offs + (short) st->a; break; case 1: - // simple pointer dereference: *a - jump_offs = OPA(ptr); + // variable indexed array: a + *b (only +ve) + jump_offs = (op_a + OPB(uint))->uint_var; break; case 2: // constant indexed pointer: *a + b (supports -ve offset) diff --git a/libs/gamecode/test/test-jump.c b/libs/gamecode/test/test-jump.c index 59e40554d..d05d6b92b 100644 --- a/libs/gamecode/test/test-jump.c +++ b/libs/gamecode/test/test-jump.c @@ -19,7 +19,7 @@ static dstatement_t jump_A_statements[] = { }; static dstatement_t jump_B_statements[] = { - { OP(0, 0, 0, OP_JUMP_B), 3, 0, 0 }, + { OP(0, 0, 0, OP_JUMP_B), 1, 2, 0 }, { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, { OP(0, 0, 0, OP_LEA_A), 1, 0, 0 }, { OP(0, 0, 0, OP_LEA_A), 1, 0, 4 }, From 7971bcd91c9cadb752e03c09436e9f76e9db9605 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 22:37:03 +0900 Subject: [PATCH 276/360] [gamecode] Sort out shr's opname for easier searching Since the operand types sort out the difference between asr and shr, no need to give them different opnames. Means qfcc doesn't need to worry about which one it's searching for. --- libs/gamecode/opcodes.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index a07714d88..7c0758a64 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -361,13 +361,14 @@ scale_formats = { }, } shiftops_formats = { - "opcode": "OP_{op_shift[u*2+r].upper()}_{shift_type[u*2+t]}_{ss+1}", - "mnemonic": "{op_shift[u*2+r]}.{shift_type[u*2+t]}", + "opcode": "OP_{mn_shift[u*2+r].upper()}_{shift_type[u*2+t]}_{ss+1}", + "mnemonic": "{mn_shift[u*2+r]}.{shift_type[u*2+t]}", "opname": "{op_shift[u*2+r]}", "widths": "{ss+1}, {ss+1}, {ss+1}", "types": "{shift_types[t][u]}, {shift_types[t][0]}, {shift_types[t][u]}", "args": { - "op_shift": ["shl", "asr", "shl", "shr"], + "mn_shift": ["shl", "asr", "shl", "shr"], + "op_shift": ["shl", "shr", "shl", "shr"], "shift_type": ['I', 'L', 'u', 'U'], "shift_types": [ ["ev_int", "ev_uint"], From 8dc4a0ea80d615a0287a88fee46f13260902dd87 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 22:39:21 +0900 Subject: [PATCH 277/360] [qfcc] Change v6p's jumpb opname to jump More ease of searching, since the operand types help greatly. --- libs/gamecode/pr_v6p_opcode.c | 2 +- tools/qfcc/source/statements.c | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/libs/gamecode/pr_v6p_opcode.c b/libs/gamecode/pr_v6p_opcode.c index a76dfe06e..bc3848de1 100644 --- a/libs/gamecode/pr_v6p_opcode.c +++ b/libs/gamecode/pr_v6p_opcode.c @@ -957,7 +957,7 @@ VISIBLE const v6p_opcode_t pr_v6p_opcodes[] = { PROG_V6P_VERSION, "%Ga", }, - [OP_JUMPB_v6p] = {"jumpb", "jumpb", + [OP_JUMPB_v6p] = {"jump", "jump", ev_void, ev_int, ev_invalid, PROG_V6P_VERSION, "%Ga[%Gb]", diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index e9b375aba..0428204d0 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -625,7 +625,7 @@ statement_is_goto (statement_t *s) { if (!s) return 0; - return !strcmp (s->opcode, "jump"); + return !strcmp (s->opcode, "jump") && !s->opb; } int @@ -633,7 +633,7 @@ statement_is_jumpb (statement_t *s) { if (!s) return 0; - return !strcmp (s->opcode, "jumpb"); + return !strcmp (s->opcode, "jump") && s->opb; } int @@ -1251,7 +1251,7 @@ statement_branch (sblock_t *sblock, expr_t *e) } if (e->e.branch.type == pr_branch_jump) { if (e->e.branch.index) { - s = new_statement (st_flow, "jumpb", e); + s = new_statement (st_flow, "jump", e); sblock = statement_subexpr (sblock, e->e.branch.target, &s->opa); sblock = statement_subexpr (sblock, e->e.branch.index, &s->opb); } else { From edf7a781fd0dcadb597e9320d3fcf331d79991c9 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 30 Jan 2022 22:40:37 +0900 Subject: [PATCH 278/360] [qfcc] Map uint to int for some intructions Many math instructions don't care about the difference between signed and unsigned operands and are thus specified using int, but need to be usable with uint. div is NOT mapped because there is a difference: 0x8000 / 2 (16-bit) is 0x4000 unsigned but 0xc000 signed, and 0x8000 / 0xfffe is 0 unsigned and 0x4000 signed. This means I'll need to add some more instructions. Not sure what to do about % and %% though as that's a lot of instructions (12). --- tools/qfcc/source/opcodes.c | 46 +++++++++++++++++++++++++++++++++---- 1 file changed, 41 insertions(+), 5 deletions(-) diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index 79cc48943..dcb6342cc 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -230,8 +230,30 @@ v6p_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, return op; } -static etype_t -operand_type (operand_t *op) +static const char *unsigned_demote_ops[] = { + "add", + "bitand", + "bitnot", + "bitor", + "bitxor", + "eq", + "ifnz", + "ifz", + "mul", + "ne", + "sub", +}; + +static int +ud_compare (const void *_a, const void *_b) +{ + const char *a = _a; + const char *b = *(const char **)_b; + return strcmp (a, b); +} + +static etype_t __attribute__((pure)) +operand_type (const operand_t *op, const char *name) { if (!op) { return ev_invalid; @@ -240,6 +262,20 @@ operand_type (operand_t *op) if (type == ev_vector || type == ev_quaternion) { return ev_float; } + if (type == ev_uint || type == ev_ulong) { + if (bsearch (name, unsigned_demote_ops, + sizeof (unsigned_demote_ops) + / sizeof (unsigned_demote_ops[0]), + sizeof (unsigned_demote_ops[0]), + ud_compare)) { + if (type == ev_uint) { + type = ev_int; + } + if (type == ev_ulong) { + type = ev_long; + } + } + } return type; } @@ -266,9 +302,9 @@ rua_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, opcode_t search_op = { .opname = name, .types = { - operand_type (op_a), - operand_type (op_b), - operand_type (op_c), + operand_type (op_a, name), + operand_type (op_b, name), + operand_type (op_c, name), }, .widths = { operand_width (op_a), From c5ae1ae13c0da975b021e337267acad99734ac14 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 31 Jan 2022 14:03:36 +0900 Subject: [PATCH 279/360] [ruamoko] Check self is within progs memory Changes a segfault to a runtime error, which beats the risk of self pointing somewhere that doesn't segrault. --- libs/ruamoko/rua_obj.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index 2fe0b85f7..3bbb974a5 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -1536,6 +1536,9 @@ rua_obj_msgSend (progs_t *pr) R_INT (pr) = P_INT (pr, 0); return; } + if (P_UINT (pr, 0) >= pr->globals_size) { + PR_RunError (pr, "invalid self: %x", P_UINT (pr, 0)); + } if (!_cmd) PR_RunError (pr, "null selector"); imp = obj_msg_lookup (probj, self, _cmd); From cabb53e693b2d182be3b71e047639ff4fbce20da Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 31 Jan 2022 16:51:46 +0900 Subject: [PATCH 280/360] [gamecode] Skip return ptr restore if depth changed When calling a builtin, normally the return pointer needs to be restored, but if the builtin changes the call depth (usually by effecting "return foo()" as in support for objects, but possibly setjmp/longjmp when they are implemented), then the return pointer must not be restored. This gets vkgen past object allocation, but it dies when trying to send messages to super. This appears to be a compiler bug. --- libs/gamecode/pr_exec.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 15c63d0a4..cd493bea8 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -452,9 +452,12 @@ PR_CallFunction (progs_t *pr, pr_func_t fnum, pr_type_t *return_ptr) PR_GetString (pr, f->descriptor->name), f->func); } pr_type_t *saved_return = pr->pr_return; + int builtin_depth = pr->pr_depth; pr->pr_return = return_ptr; f->func (pr); - pr->pr_return = saved_return; + if (builtin_depth == pr->pr_depth) { + pr->pr_return = saved_return; + } return 0; } else { PR_EnterFunction (pr, f); From 92711e778ce87c73864c7a083eb0a13ce093efab Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 31 Jan 2022 19:04:18 +0900 Subject: [PATCH 281/360] [ruamoko] Set params in obj_msgSend_super only for v6p progs In Ruamoko ISA progs, the param pointers point to the stack and generally must most be manipulated by builtins, and there is no need anyway as Ruamoko doesn't have RCALL. Fixes the mangling of .super. --- libs/ruamoko/rua_obj.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index 3bbb974a5..971ba55b8 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -1565,7 +1565,9 @@ rua_obj_msgSend_super (progs_t *pr) PR_GetString (pr, object_get_class_name (probj, self)), PR_GetString (pr, probj->selector_names[_cmd->sel_id])); } - pr->pr_params[0] = pr->pr_real_params[0]; + if (pr->progs->version < PROG_VERSION) { + pr->pr_params[0] = pr->pr_real_params[0]; + } P_POINTER (pr, 0) = super->self; PR_CallFunction (pr, imp, pr->pr_return); } From 712d800491566c880b6b565dfb40d36fbefc2365 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 31 Jan 2022 23:32:38 +0900 Subject: [PATCH 282/360] [gamecode] Save return ptr for chained calls It turns out the return pointer still needs to be saved even when a builtin sets up a chain call to progs, but rather than the pointer being simply restored, it needs to be saved in the call stack exactly as if the function was called directly by progs. This fixes the invalid self issue quite thoroughly: parameter state seems to be correct across all calls now. I should set up an automated test now that I know and understand the situation. --- libs/gamecode/pr_exec.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index cd493bea8..200e0c0d8 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -457,6 +457,8 @@ PR_CallFunction (progs_t *pr, pr_func_t fnum, pr_type_t *return_ptr) f->func (pr); if (builtin_depth == pr->pr_depth) { pr->pr_return = saved_return; + } else if (builtin_depth < pr->pr_depth) { + pr->pr_stack[builtin_depth].return_ptr = saved_return; } return 0; } else { From 98215b46ad3cbf9074b669776bf438d3ecc61f89 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 31 Jan 2022 23:37:03 +0900 Subject: [PATCH 283/360] [ruamoko] Cast autoreleaseIMP to avoid ... The ABI for the Ruamoko ISA set currently puts va_list into the parameter stream whenever a varargs function is called. Unfortunately, IMP is declared with ... and thus cannot be used directly unless all methods become varargs, but I think that would cause even more headaches. --- ruamoko/lib/Object.r | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/ruamoko/lib/Object.r b/ruamoko/lib/Object.r index bccea1de4..03a1519ad 100644 --- a/ruamoko/lib/Object.r +++ b/ruamoko/lib/Object.r @@ -77,10 +77,12 @@ BOOL (id object) object_is_meta_class = #0; @end +typedef void arIMP(id, SEL, id); + @static BOOL allocDebug; @static Class autoreleaseClass; @static SEL autoreleaseSelector; -@static IMP autoreleaseIMP; +@static arIMP autoreleaseIMP; @implementation Object @@ -89,7 +91,7 @@ BOOL (id object) object_is_meta_class = #0; //allocDebug = localinfo ("AllocDebug"); autoreleaseClass = [AutoreleasePool class]; autoreleaseSelector = @selector(addObject:); - autoreleaseIMP = [autoreleaseClass methodForSelector: autoreleaseSelector]; + autoreleaseIMP = (arIMP)[autoreleaseClass methodForSelector: autoreleaseSelector]; return; } From e3f88b2b9c7a5178fda413e5278271387a773e5a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 31 Jan 2022 23:40:21 +0900 Subject: [PATCH 284/360] [qwaq] Align progs memory to 64 bytes It doesn't do much good for dynamic progs memory because zone currently aligns to 8 bytes (oops, forgot to fix that), but at least the stack and globals are properly aligned. --- ruamoko/qwaq/builtins/main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ruamoko/qwaq/builtins/main.c b/ruamoko/qwaq/builtins/main.c index 0215ced3f..7d34e1785 100644 --- a/ruamoko/qwaq/builtins/main.c +++ b/ruamoko/qwaq/builtins/main.c @@ -119,7 +119,7 @@ load_file (progs_t *pr, const char *name, off_t *_size) static void * allocate_progs_mem (progs_t *pr, int size) { - return malloc (size); + return aligned_alloc (64, size); } static void From 175cc408d8ae28e4865bd6805dbc60fbb9b43bb3 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 31 Jan 2022 23:44:09 +0900 Subject: [PATCH 285/360] [qwaq] Update bi_printf to work with Ruamoko's va_list Same deal as for test_bi in qfcc's test harness. I really need to consolidate all these little functions. --- ruamoko/qwaq/builtins/main.c | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/ruamoko/qwaq/builtins/main.c b/ruamoko/qwaq/builtins/main.c index 7d34e1785..670515fc0 100644 --- a/ruamoko/qwaq/builtins/main.c +++ b/ruamoko/qwaq/builtins/main.c @@ -152,6 +152,19 @@ bi_printf (progs_t *pr) pr_type_t **args = pr->pr_params + 1; dstring_t *dstr = dstring_new (); + if (pr->progs->version == PROG_VERSION) { + __auto_type va_list = &P_PACKED (pr, pr_va_list_t, 1); + count = va_list->count; + if (count) { + args = alloca (count * sizeof (pr_type_t *)); + for (int i = 0; i < count; i++) { + args[i] = &pr->pr_globals[va_list->list + i * 4]; + } + } else { + args = 0; + } + } + PR_Sprintf (pr, dstr, "bi_printf", fmt, count, args); if (dstr->str) { Sys_Printf ("%s", dstr->str); From e7ac6376876591b361151d069a98abb1b258977d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 31 Jan 2022 23:45:29 +0900 Subject: [PATCH 286/360] [ruamoko] Wrap hash table callbacks with push/pop frame Builtins that call progs with parameters now must always wrap the call to PR_ExecuteProgram so that the data stack is properly preserved across the call. I need to do an audit of all the calls to PR_ExecuteProgram. --- libs/ruamoko/rua_hash.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/libs/ruamoko/rua_hash.c b/libs/ruamoko/rua_hash.c index c2cf1f8f7..c4939e1e7 100644 --- a/libs/ruamoko/rua_hash.c +++ b/libs/ruamoko/rua_hash.c @@ -95,48 +95,59 @@ static const char * bi_get_key (const void *key, void *_ht) { bi_hashtab_t *ht = (bi_hashtab_t *)_ht; + PR_PushFrame (ht->pr); PR_RESET_PARAMS (ht->pr); P_INT (ht->pr, 0) = (intptr_t) (key); P_INT (ht->pr, 1) = ht->ud; ht->pr->pr_argc = 2; PR_ExecuteProgram (ht->pr, ht->gk); - return PR_GetString (ht->pr, R_STRING (ht->pr)); + pr_string_t string = R_STRING (ht->pr); + PR_PopFrame (ht->pr); + return PR_GetString (ht->pr, string); } static uintptr_t bi_get_hash (const void *key, void *_ht) { bi_hashtab_t *ht = (bi_hashtab_t *)_ht; + PR_PushFrame (ht->pr); PR_RESET_PARAMS (ht->pr); P_INT (ht->pr, 0) = (intptr_t) (key); P_INT (ht->pr, 1) = ht->ud; ht->pr->pr_argc = 2; PR_ExecuteProgram (ht->pr, ht->gh); - return R_INT (ht->pr); + int hash = R_INT (ht->pr); + PR_PopFrame (ht->pr); + return hash; } static int bi_compare (const void *key1, const void *key2, void *_ht) { bi_hashtab_t *ht = (bi_hashtab_t *)_ht; + PR_PushFrame (ht->pr); PR_RESET_PARAMS (ht->pr); P_INT (ht->pr, 0) = (intptr_t) (key1); P_INT (ht->pr, 1) = (intptr_t) (key2); P_INT (ht->pr, 2) = ht->ud; ht->pr->pr_argc = 3; PR_ExecuteProgram (ht->pr, ht->cmp); - return R_INT (ht->pr); + int cmp = R_INT (ht->pr); + PR_PopFrame (ht->pr); + return cmp; } static void bi_free (void *key, void *_ht) { bi_hashtab_t *ht = (bi_hashtab_t *)_ht; + PR_PushFrame (ht->pr); PR_RESET_PARAMS (ht->pr); P_INT (ht->pr, 0) = (intptr_t) (key); P_INT (ht->pr, 1) = ht->ud; ht->pr->pr_argc = 2; PR_ExecuteProgram (ht->pr, ht->f); + PR_PopFrame (ht->pr); } static void From 5d41e90cc708efe2d899aacafc863a04c20876dc Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Mon, 31 Jan 2022 23:47:47 +0900 Subject: [PATCH 287/360] [gamecode] Remove pushregs and popregs specs They have been redundant since the operations were moved into with. --- libs/gamecode/opcodes.py | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 7c0758a64..61ad591ab 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -320,14 +320,6 @@ push_formats = { "push_types": address_types, }, } -pushregs_formats = { - "opcode": "OP_PUSHREGS", - "mnemonic": "pushregs", - "opname": "pushregs", - "widths": "0, 0, 0", - "types": "ev_invalid, ev_invalid, ev_invalid", - "format": None, -} pop_formats = { "opcode": "OP_POP_{op_mode[mm]}_{ss+1}", "mnemonic": "pop", @@ -341,14 +333,6 @@ pop_formats = { "pop_types": address_types, }, } -popregs_formats = { - "opcode": "OP_POPREGS", - "mnemonic": "popregs", - "opname": "popregs", - "widths": "0, 0, 0", - "format": None, - "types": "ev_invalid, ev_invalid, ev_invalid", -} scale_formats = { "opcode": "OP_SCALE_{scale_type[t]}_{ss+1}", "mnemonic": "scale.{scale_type[t]}", @@ -530,9 +514,7 @@ group_map = { "move": move_formats, "noop": noop_formats, "push": push_formats, - "pushregs": pushregs_formats, "pop": pop_formats, - "popregs": popregs_formats, "scale": scale_formats, "shiftops": shiftops_formats, "statef": statef_formats, From b8c2b7f8565ca4a5c99a295d8fec3f981c07fde5 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 1 Feb 2022 09:24:02 +0900 Subject: [PATCH 288/360] [ruamoko] Make a common sprintf wrapper function This takes care of converting from progs varargs to what PR_Sprintf expects. I got tired of modifying the wrappers when I found a third one. --- include/rua_internal.h | 5 +++++ libs/ruamoko/rua_string.c | 26 +++++++++++++++++++++++--- ruamoko/qwaq/builtins/main.c | 19 ++----------------- tools/qfcc/test/test-bi.c | 26 +++++++------------------- 4 files changed, 37 insertions(+), 39 deletions(-) diff --git a/include/rua_internal.h b/include/rua_internal.h index 24e16cc6e..a41177bae 100644 --- a/include/rua_internal.h +++ b/include/rua_internal.h @@ -33,6 +33,9 @@ #include "QF/quakeio.h" +struct progs_s; +struct dstring_s; + void RUA_Cbuf_Init (struct progs_s *pr, int secure); void RUA_Cmd_Init (struct progs_s *pr, int secure); void RUA_Cvar_Init (struct progs_s *pr, int secure); @@ -49,6 +52,8 @@ void RUA_String_Init (struct progs_s *pr, int secure); void RUA_QFile_Init (struct progs_s *pr, int secure); void RUA_QFS_Init (struct progs_s *pr, int secure); +void RUA_Sprintf (struct progs_s *pr, struct dstring_s *dstr); + int QFile_AllocHandle (struct progs_s *pr, QFile *file); QFile *QFile_GetFile (struct progs_s *pr, int handle); struct plitem_s *Plist_GetItem (struct progs_s *pr, int handle); diff --git a/libs/ruamoko/rua_string.c b/libs/ruamoko/rua_string.c index e01ab9716..4fdbab706 100644 --- a/libs/ruamoko/rua_string.c +++ b/libs/ruamoko/rua_string.c @@ -60,16 +60,36 @@ bi_strlen (progs_t *pr) R_INT (pr) = strlen(s); } -static void -bi_sprintf (progs_t *pr) +void +RUA_Sprintf (progs_t *pr, dstring_t *dstr) { const char *fmt = P_GSTRING (pr, 0); int count = pr->pr_argc - 1; pr_type_t **args = pr->pr_params + 1; + + if (pr->progs->version == PROG_VERSION) { + __auto_type va_list = &P_PACKED (pr, pr_va_list_t, 1); + count = va_list->count; + if (count) { + args = alloca (count * sizeof (pr_type_t *)); + for (int i = 0; i < count; i++) { + args[i] = &pr->pr_globals[va_list->list + i * 4]; + } + } else { + args = 0; + } + } + + PR_Sprintf (pr, dstr, "bi_sprintf", fmt, count, args); +} + +static void +bi_sprintf (progs_t *pr) +{ dstring_t *dstr; dstr = dstring_newstr (); - PR_Sprintf (pr, dstr, "bi_sprintf", fmt, count, args); + RUA_Sprintf (pr, dstr); RETURN_STRING (pr, dstr->str); dstring_delete (dstr); } diff --git a/ruamoko/qwaq/builtins/main.c b/ruamoko/qwaq/builtins/main.c index 670515fc0..8e9449d40 100644 --- a/ruamoko/qwaq/builtins/main.c +++ b/ruamoko/qwaq/builtins/main.c @@ -53,6 +53,7 @@ #include "QF/zone.h" #include "compat.h" +#include "rua_internal.h" #include "ruamoko/qwaq/qwaq.h" #include "ruamoko/qwaq/debugger/debug.h" @@ -147,25 +148,9 @@ init_qf (void) static void bi_printf (progs_t *pr) { - const char *fmt = P_GSTRING (pr, 0); - int count = pr->pr_argc - 1; - pr_type_t **args = pr->pr_params + 1; dstring_t *dstr = dstring_new (); - if (pr->progs->version == PROG_VERSION) { - __auto_type va_list = &P_PACKED (pr, pr_va_list_t, 1); - count = va_list->count; - if (count) { - args = alloca (count * sizeof (pr_type_t *)); - for (int i = 0; i < count; i++) { - args[i] = &pr->pr_globals[va_list->list + i * 4]; - } - } else { - args = 0; - } - } - - PR_Sprintf (pr, dstr, "bi_printf", fmt, count, args); + RUA_Sprintf (pr, dstr); if (dstr->str) { Sys_Printf ("%s", dstr->str); } diff --git a/tools/qfcc/test/test-bi.c b/tools/qfcc/test/test-bi.c index 412a341bf..e12220f8f 100644 --- a/tools/qfcc/test/test-bi.c +++ b/tools/qfcc/test/test-bi.c @@ -40,37 +40,25 @@ #include "QF/dstring.h" #include "QF/progs.h" +#include "rua_internal.h" #include "test-bi.h" static void bi_printf (progs_t *pr) { - const char *fmt = P_GSTRING (pr, 0); - int count = pr->pr_argc - 1; - pr_type_t **args = pr->pr_params + 1; static dstring_t *dstr; - if (!dstr) + if (!dstr) { dstr = dstring_new (); - else + } else { dstring_clear (dstr); - - if (pr->progs->version == PROG_VERSION) { - __auto_type va_list = &P_PACKED (pr, pr_va_list_t, 1); - count = va_list->count; - if (count) { - args = alloca (count * sizeof (pr_type_t *)); - for (int i = 0; i < count; i++) { - args[i] = &pr->pr_globals[va_list->list + i * 4]; - } - } else { - args = 0; - } } - PR_Sprintf (pr, dstr, "bi_printf", fmt, count, args); - if (dstr->str) + RUA_Sprintf (pr, dstr); + + if (dstr->str) { fputs (dstr->str, stdout); + } } static void From 2fcec6e5cb693200b2ef6f1157c6589dfbcc3f4b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 1 Feb 2022 11:56:45 +0900 Subject: [PATCH 289/360] [zone] Move heap check to Z_TagMalloc Since Z_Malloc uses Z_TagMalloc to do the work, this ensures the check is always run. Also, add the check to Z_Realloc when it needs to adjust an existing block. --- libs/util/zone.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/libs/util/zone.c b/libs/util/zone.c index 88b3e7ecd..ce02fa76c 100644 --- a/libs/util/zone.c +++ b/libs/util/zone.c @@ -202,8 +202,6 @@ Z_Malloc (memzone_t *zone, size_t size) { void *buf; - if (!developer || developer->int_val & SYS_dev) - Z_CheckHeap (zone); // DEBUG buf = Z_TagMalloc (zone, size, 1); if (!buf) { const char *msg; @@ -224,6 +222,9 @@ Z_TagMalloc (memzone_t *zone, size_t size, int tag) int requested_size = size; memblock_t *start, *rover, *new, *base; + if (!developer || developer->int_val & SYS_dev) + Z_CheckHeap (zone); // DEBUG + if (!tag) { if (zone->error) zone->error (zone->data, "Z_TagMalloc: tried to use a 0 tag"); @@ -290,6 +291,9 @@ Z_Realloc (memzone_t *zone, void *ptr, size_t size) if (!ptr) return Z_Malloc (zone, size); + if (!developer || developer->int_val & SYS_dev) + Z_CheckHeap (zone); // DEBUG + block = (memblock_t *) ((byte *) ptr - sizeof (memblock_t)); if (block->id != ZONEID/* || block->id2 != ZONEID*/) { if (zone->error) From bea1155e9e551e7d5797b844b1122006c054bdd4 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 1 Feb 2022 12:24:46 +0900 Subject: [PATCH 290/360] [qwaq] Give qwaq progs a stack of 64kB 16kW should be enough as a default (when I get around to making it configurable). Stops vkgen from trashing its heap with the stack. --- ruamoko/qwaq/builtins/main.c | 1 + 1 file changed, 1 insertion(+) diff --git a/ruamoko/qwaq/builtins/main.c b/ruamoko/qwaq/builtins/main.c index 8e9449d40..59080dd17 100644 --- a/ruamoko/qwaq/builtins/main.c +++ b/ruamoko/qwaq/builtins/main.c @@ -227,6 +227,7 @@ load_progs (progs_t *pr, const char *name) pr->progs_name = name; pr->max_edicts = 1; pr->zone_size = 1024*1024; + pr->stack_size = 64*1024; PR_LoadProgsFile (pr, file, size); Qclose (file); if (!PR_RunLoadFuncs (pr)) From f714b6fbea441f94af304153c64aafeedeb5bc32 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 1 Feb 2022 12:45:18 +0900 Subject: [PATCH 291/360] [qwaq] Up qwaq progs heap to 2MB or 512kW (kilowatts? :P). Barely enough for vkgen to run (it runs out if auto release is run during scan_types, probably due to fragmentation). I imagine I need to look into better memory management schemes, especially since I want to make zone allocations 64-byte aligned (instead of the current 8). And it doesn't help that 16 words per allocation are dedicated to the zone management. Anyway, with this, vgken runs and produces sufficiently correct results for the rest of QF to build, so long as qfcc is not optimizing. --- ruamoko/qwaq/builtins/main.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ruamoko/qwaq/builtins/main.c b/ruamoko/qwaq/builtins/main.c index 59080dd17..3a0561035 100644 --- a/ruamoko/qwaq/builtins/main.c +++ b/ruamoko/qwaq/builtins/main.c @@ -226,7 +226,7 @@ load_progs (progs_t *pr, const char *name) } pr->progs_name = name; pr->max_edicts = 1; - pr->zone_size = 1024*1024; + pr->zone_size = 2*1024*1024; pr->stack_size = 64*1024; PR_LoadProgsFile (pr, file, size); Qclose (file); From 64c8c02eacfee5f90804464a786ffc7bedbeb3d2 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 1 Feb 2022 13:24:27 +0900 Subject: [PATCH 292/360] [qfcc] Add pragma to control optimization And force a couple of tests to be built with optimization. I'll probably add it to most, if not all, but for now I'm clearing up tests as I go. --- tools/qfcc/source/pragma.c | 20 ++++++++++++++++++++ tools/qfcc/test/dealloc-warn3.r | 1 + tools/qfcc/test/return-postop.r | 1 + 3 files changed, 22 insertions(+) diff --git a/tools/qfcc/source/pragma.c b/tools/qfcc/source/pragma.c index 9e3a393aa..fb72130f4 100644 --- a/tools/qfcc/source/pragma.c +++ b/tools/qfcc/source/pragma.c @@ -125,6 +125,24 @@ set_warn (pragma_arg_t *args) } } +static void +set_optimize (pragma_arg_t *args) +{ + if (!args) { + warning (0, "missing warn flag"); + return; + } + const char *flag = args->arg; + if (!strcmp (flag, "on") || !strcmp (flag, "!off")) { + options.code.optimize = true; + } else if (!strcmp (flag, "!on") || !strcmp (flag, "off")) { + options.code.optimize = false; + } + if (args->next) { + warning (0, "pragma optimize: ignoring extra arguments"); + } +} + void pragma_process () { @@ -143,6 +161,8 @@ pragma_process () set_bug (pragma_args->next); } else if (!strcmp (id, "warn")) { set_warn (pragma_args->next); + } else if (!strcmp (id, "optimize")) { + set_optimize (pragma_args->next); } else { warning (0, "unknown pragma: '%s'", id); } diff --git a/tools/qfcc/test/dealloc-warn3.r b/tools/qfcc/test/dealloc-warn3.r index 32427e2ff..a8dd2d2b4 100644 --- a/tools/qfcc/test/dealloc-warn3.r +++ b/tools/qfcc/test/dealloc-warn3.r @@ -1,4 +1,5 @@ #pragma warn error +#pragma optimize on @interface Object { diff --git a/tools/qfcc/test/return-postop.r b/tools/qfcc/test/return-postop.r index 5ec27f4a1..bdf244f98 100644 --- a/tools/qfcc/test/return-postop.r +++ b/tools/qfcc/test/return-postop.r @@ -1,3 +1,4 @@ +#pragma optimize on #include "test-harness.h" int counter; From e0c5c475ea257278380923a88a506373969d06ce Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 1 Feb 2022 13:26:01 +0900 Subject: [PATCH 293/360] [qfcc] Modify the modulo tests to be compatible with Ruamoko ISA Surprisingly, it passes (I didn't expect it to due to the doubles). I'll look into to it further later on. --- tools/qfcc/test/modulo.r | 35 +++++++++++++++++++++++++++++------ 1 file changed, 29 insertions(+), 6 deletions(-) diff --git a/tools/qfcc/test/modulo.r b/tools/qfcc/test/modulo.r index 2d31a69a2..6fb69490c 100644 --- a/tools/qfcc/test/modulo.r +++ b/tools/qfcc/test/modulo.r @@ -1,3 +1,7 @@ +#if !defined(__RUAMOKO__) || __RUAMOKO__ < 2 +# define test_traditional +#endif + void printf (string ftm, ...) = #0; float snafu (float a, float b) @@ -21,6 +25,7 @@ double dmodulo (double a, double b) return a %% b; } +#ifdef test_traditional #pragma traditional float foo (float a, float b) { @@ -45,6 +50,7 @@ float baz (float a, float b) return c; } #pragma advanced +#endif @overload int test (string name, string op, int (func)(int a, int b), int a, int b, int c) @@ -53,10 +59,12 @@ test (string name, string op, int (func)(int a, int b), int a, int b, int c) ret = func (a, b); if (ret != c) { +#ifdef test_traditional if (func == baz) printf ("%s: (%d + %d) %% (%d - %d): %d != %d\n", name, a, b, a, b, ret, c); else +#endif printf ("%s: %d %s %d: %d != %d\n", name, a, op, b, ret, c); return 1; @@ -72,10 +80,12 @@ test (string name, string op, float (func)(float a, float b), ret = func (a, b); if (ret != c) { +#ifdef test_traditional if (func == baz) printf ("%s: (%g + %g) %% (%g - %g): %g != %g\n", name, a, b, a, b, ret, c); else +#endif printf ("%s: %g %s %g: %g != %g\n", name, a, op, b, ret, c); return 1; @@ -91,42 +101,55 @@ test (string name, string op, double (func)(double a, double b), ret = func (a, b); if (ret != c) { +#ifdef test_traditional if (func == baz) printf ("%s: (%g + %g) %% (%g - %g): %g != %g\n", name, a, b, a, b, ret, c); else +#endif printf ("%s: %g %s %g: %g != %g\n", name, a, op, b, ret, c); return 1; } return 0; } +#ifdef test_traditional +typedef float restype; +#else +typedef int restype; +#endif -float main (void) +restype main (void) { - float res = 0; + restype res = 0; +#ifdef test_traditional res |= test ("foo", "%", foo, 5, 3, 2); res |= test ("bar", "%", bar, 5, 3, 2); res |= test ("baz", "%", baz, 5, 3, 0); +#endif res |= test ("snafu", "%", snafu, 5, 3, 2); - +#ifdef test_traditional res |= test ("foo", "%", foo, -5, 3, -2); res |= test ("bar", "%", bar, -5, 3, -2); res |= test ("baz", "%", baz, -5, 3, -2); +#endif res |= test ("snafu", "%", snafu, -5, 3, -2); - +#ifdef test_traditional res |= test ("foo", "%", foo, 5, -3, 2); res |= test ("bar", "%", bar, 5, -3, 2); res |= test ("baz", "%", baz, 5, -3, 2); +#endif res |= test ("snafu", "%", snafu, 5, -3, 2); - +#ifdef test_traditional res |= test ("foo", "%", foo, -5, -3, -2); res |= test ("bar", "%", bar, -5, -3, -2); res |= test ("baz", "%", baz, -5, -3, 0); +#endif res |= test ("snafu", "%", snafu, -5, -3, -2); - +#ifdef test_traditional res |= test ("foo", "%", foo, 5, 3.5, 1.5); res |= test ("foo", "%", foo, -5, 3.5, -1.5); +#endif res |= test ("snafu", "%", snafu, 5, 3.5, 1.5); res |= test ("snafu", "%", snafu, -5, 3.5, -1.5); From fc56d1c6e29326f0b811ff12256cfe6d041567c3 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 1 Feb 2022 14:54:22 +0900 Subject: [PATCH 294/360] [qfcc] Use dynamic addressing for Ruamoko move source This fixes the incorrect pointer being used in movep instructions in Ruamoko progs, as well as 3 of the test cases. --- tools/qfcc/source/statements.c | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 0428204d0..3f60f15fa 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -808,6 +808,8 @@ is_indirect (expr_t *e) static sblock_t *addressing_mode (sblock_t *sblock, expr_t *ref, operand_t **base, operand_t **offset, pr_ushort_t *mode); +static statement_t *lea_statement (operand_t *pointer, operand_t *offset, + expr_t *e); static sblock_t * expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) @@ -870,7 +872,13 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) // shouldn't emit code... sblock = statement_subexpr (sblock, src_expr, &use); } - src = operand_address (src, src_expr); + if (options.code.progsversion == PROG_VERSION) { + s = lea_statement (src, 0, src_expr); + sblock_add_statement (sblock, s); + src = s->opc; + } else { + src = operand_address (src, src_expr); + } need_ptr = 1; } } From c84fb3e6d360ad92f99b0ede6c8740adda45bf62 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 1 Feb 2022 16:08:58 +0900 Subject: [PATCH 295/360] [qfcc] Use a hidden local variable for pascal functions This gets gcd.pas working nicely with the Ruamoko ISA, and keeps things reasonably nice vor v6p (it will likely do better with global CSE). --- tools/qfcc/source/qp-parse.y | 45 ++++++++++++++++++++++++++++++++---- 1 file changed, 41 insertions(+), 4 deletions(-) diff --git a/tools/qfcc/source/qp-parse.y b/tools/qfcc/source/qp-parse.y index 550f8e3f8..8a809bacb 100644 --- a/tools/qfcc/source/qp-parse.y +++ b/tools/qfcc/source/qp-parse.y @@ -164,6 +164,32 @@ build_dotmain (symbol_t *program) build_code_function (dotmain, 0, code); } +static symbol_t * +function_value (function_t *func) +{ + symbol_t *ret = 0; + if (func->type->t.func.type) { + ret = symtab_lookup (func->locals, ".ret"); + if (!ret || ret->table != func->locals) { + ret = new_symbol_type (".ret", func->type->t.func.type); + initialize_def (ret, 0, func->locals->space, sc_local, + func->locals); + } + } + return ret; +} + +static expr_t * +function_return (function_t *func) +{ + symbol_t *ret = function_value (func); + expr_t *ret_val = 0; + if (ret) { + ret_val = new_symbol_expr (ret); + } + return ret_val; +} + %} %% @@ -270,10 +296,11 @@ subprogram_declaration current_storage); current_symtab = current_func->locals; current_storage = sc_local; + function_value (current_func); } declarations compound_statement ';' { - append_expr ($5, new_return_expr (0)); + append_expr ($5, new_return_expr (function_return (current_func))); build_code_function ($1, 0, $5); current_symtab = current_func->parameters->parent; current_storage = $3; @@ -376,8 +403,18 @@ statement : variable ASSIGNOP expression { $$ = $1; - if ($$->type == ex_symbol && extract_type ($$) == ev_func) - $$ = new_ret_expr ($$->e.symbol->type->t.func.type); + if ($$->type == ex_symbol && $$->e.symbol->sy_type == sy_func) { + if ($$->e.symbol->s.func != current_func) { + $$ = error ($$, "cannot assign to other function"); + } else { + symbol_t *ret = function_value (current_func); + if (!ret) { + $$ = error ($$, "cannot assign to procedure"); + } else { + $$ = new_symbol_expr (ret); + } + } + } $$ = assign_expr ($$, $3); } | procedure_statement @@ -398,7 +435,7 @@ statement } | RETURN { - $$ = return_expr (current_func, 0); + $$ = return_expr (current_func, function_return (current_func)); } ; From 6514e09e7cfbffff5e9485ebe80d009d165677e0 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 1 Feb 2022 16:43:29 +0900 Subject: [PATCH 296/360] [gamecode] Use an explicit size for the null page It's currently only 4 (or even 3 for v6) words, but this fixes false positives when checking for null pointers in Ruamoko progs due to pr_return pointing to the return buffer and thus outside the progs memory map resulting in an impossible to exceed value. --- include/QF/progs.h | 3 ++- libs/gamecode/pr_exec.c | 2 +- libs/gamecode/pr_resolve.c | 1 + 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 769fdb533..5a00afd46 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1942,7 +1942,8 @@ struct progs_s { pr_def_t *pr_fielddefs; dstatement_t *pr_statements; pr_type_t *pr_globals; - unsigned globals_size; + pr_uint_t globals_size; + pr_uint_t null_size; ///< size of block considered null page pr_uivec4_t pr_bases; ///< base registers (index in opcode) ///@} diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 200e0c0d8..89890908f 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -351,7 +351,7 @@ PR_LeaveFunction (progs_t *pr, int to_engine) VISIBLE void PR_BoundsCheckSize (progs_t *pr, pr_ptr_t addr, unsigned size) { - if (addr < (pr_ptr_t) (pr->pr_return - pr->pr_globals)) + if (addr < pr->null_size) PR_RunError (pr, "null pointer access"); if (addr >= pr->globals_size || size > (unsigned) (pr->globals_size - addr)) diff --git a/libs/gamecode/pr_resolve.c b/libs/gamecode/pr_resolve.c index 864baa443..008c1abed 100644 --- a/libs/gamecode/pr_resolve.c +++ b/libs/gamecode/pr_resolve.c @@ -142,6 +142,7 @@ PR_ResolveGlobals (progs_t *pr) goto error; pr->pr_param_alignment = G_INT (pr, def->ofs); } + pr->null_size = pr->pr_return - pr->pr_globals; memcpy (pr->pr_real_params, pr->pr_params, sizeof (pr->pr_params)); if (!pr->globals.ftime) {//FIXME double time if ((def = PR_FindGlobal (pr, "time"))) From 4ec3486a4b8ee049ae1a756da2ad7463bf271056 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 1 Feb 2022 20:01:13 +0900 Subject: [PATCH 297/360] [qfcc] Make lea generate a pointer operand I really need to come up with a better way to get the result type into the flow analyser. However, this fixes the aliasing ICE when optimizing Ruamoko code that uses struct assignment. --- tools/qfcc/source/statements.c | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 3f60f15fa..bfa782205 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -873,6 +873,13 @@ expr_assign_copy (sblock_t *sblock, expr_t *e, operand_t **op, operand_t *src) sblock = statement_subexpr (sblock, src_expr, &use); } if (options.code.progsversion == PROG_VERSION) { + // FIXME it was probably a mistake extracting the operand + // type from the statement expression in dags. Also, can't + // use address_expr() because src_expr may be a function call + // and unary_expr doesn't like that + src_expr = expr_file_line ( + new_address_expr (get_type (src_expr), src_expr, 0), + src_expr); s = lea_statement (src, 0, src_expr); sblock_add_statement (sblock, s); src = s->opc; From 9b81d27f1a1ff3af92c911250f5187934f1f097f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 1 Feb 2022 21:40:59 +0900 Subject: [PATCH 298/360] [qfcc] Add test for var = func(var) That is, updating a variable using a function that takes the same variable, probably very common in iterators, thus the name. It happens to be the first qfcc test specific to Ruamoko. It's really just the typedef, zerolinker, and vkgen type encoding loop stripped down for ease of debugging. Of course, it fails :) --- tools/qfcc/test/Makemodule.am | 11 +++++++++++ tools/qfcc/test/iterfunc.r | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+) create mode 100644 tools/qfcc/test/iterfunc.r diff --git a/tools/qfcc/test/Makemodule.am b/tools/qfcc/test/Makemodule.am index eaa3d673c..c82d750c4 100644 --- a/tools/qfcc/test/Makemodule.am +++ b/tools/qfcc/test/Makemodule.am @@ -30,6 +30,7 @@ test_progs_dat=\ tools/qfcc/test/func-static.dat \ tools/qfcc/test/gcd.dat \ tools/qfcc/test/infloop.dat \ + tools/qfcc/test/iterfunc.dat \ tools/qfcc/test/ivar-struct-return.dat \ tools/qfcc/test/link_order.dat \ tools/qfcc/test/lost-use.dat \ @@ -379,6 +380,16 @@ tools/qfcc/test/infloop.run: $(qfcc_test_run_deps) include $(infloop_dep) # am--include-marker r_depfiles_remade += $(infloop_dep) +tools_qfcc_test_iterfunc_dat_SOURCES=tools/qfcc/test/iterfunc.r +iterfunc_obj=$(tools_qfcc_test_iterfunc_dat_SOURCES:.r=.o) +iterfunc_dep=$(call qcautodep,$(tools_qfcc_test_iterfunc_dat_SOURCES)) +tools/qfcc/test/iterfunc.dat$(EXEEXT): $(iterfunc_obj) $(QFCC_DEP) + $(V_QFCCLD)$(QLINK) -o $@ $(iterfunc_obj) +tools/qfcc/test/iterfunc.run: $(qfcc_test_run_deps) + @$(top_srcdir)/tools/qfcc/test/build-run $@ +include $(iterfunc_dep) # am--include-marker +r_depfiles_remade += $(iterfunc_dep) + tools_qfcc_test_ivar_struct_return_dat_SOURCES=tools/qfcc/test/ivar-struct-return.r ivar_struct_return_obj=$(tools_qfcc_test_ivar_struct_return_dat_SOURCES:.r=.o) ivar_struct_return_dep=$(call qcautodep,$(tools_qfcc_test_ivar_struct_return_dat_SOURCES)) diff --git a/tools/qfcc/test/iterfunc.r b/tools/qfcc/test/iterfunc.r new file mode 100644 index 000000000..803b6a6f6 --- /dev/null +++ b/tools/qfcc/test/iterfunc.r @@ -0,0 +1,33 @@ +#include + +// can't link against libr.a (may not be built) +void *PR_FindGlobal (string name) = #0; +void printf (string fmt, ...) = #0; + +qfot_type_encodings_t *encodings; +qfot_type_t *next_type (qfot_type_t *type); + +int +main (void) +{ + int found_param = 0; + int found_zero = 0; + qfot_type_t *type; + + encodings = PR_FindGlobal (".type_encodings"); + + for (type = encodings.types; + ((int *)type - (int *) encodings.types) < encodings.size; + type = next_type (type)) { + } + return 0; +} + +qfot_type_t * +next_type (qfot_type_t *type) +{ + int size = type.size; + if (!size) + size = 4; + return (qfot_type_t *) ((int *) type + size); +} From 93840d98922db9fc838ada24fabf49d016285007 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Tue, 1 Feb 2022 21:46:28 +0900 Subject: [PATCH 299/360] [qfcc] Handle Ruamoko's call return destination Since the call instruction in the Ruamoko ISA specifies the destination of the return value of the called function, it is much like any expression type instruction in that the def referenced by its c operand is both defined and killed by the instruction. However, unlike other instructions, it really has many pseudo-operands: the arguments placed on the stack. The problem is that when one of the arguments is also the destination of the return value, the dags code wants to use the stack argument as it was the last use of the real argument. Thus, instead of using the value of the child node for the result, use the value label attached to the call node (there should be only one such label). This fixes iterfunc, typedef, zerolinker and vkgen when optimizing. Now all but the double tests and return postop tests pass (and the retun postop test is not related to the Ruamoko ISA, so fails either way). --- tools/qfcc/source/dags.c | 44 +++++++++++++++++++++++++++++++++++++++- tools/qfcc/source/flow.c | 3 +++ 2 files changed, 46 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/dags.c b/tools/qfcc/source/dags.c index 7a52a4f6b..e55688ff4 100644 --- a/tools/qfcc/source/dags.c +++ b/tools/qfcc/source/dags.c @@ -1135,6 +1135,43 @@ generate_memsetps (dag_t *dag, sblock_t *block, dagnode_t *dagnode) return dst; } +static operand_t * +generate_call (dag_t *dag, sblock_t *block, dagnode_t *dagnode) +{ + set_iter_t *var_iter; + daglabel_t *var = 0; + operand_t *operands[3] = {0, 0, 0}; + statement_t *st; + operand_t *dst; + + operands[0] = make_operand (dag, block, dagnode, 0); + if (dagnode->children[1]) { + operands[1] = make_operand (dag, block, dagnode, 1); + } + dst = operands[0]; + for (var_iter = set_first (dagnode->identifiers); var_iter; + var_iter = set_next (var_iter)) { + if (var) { + internal_error (var->expr, "more than one return value for call"); + } + var = dag->labels[var_iter->element]; + operands[2] = var->op; + dst = operands[2]; + st = build_statement ("call", operands, var->expr); + sblock_add_statement (block, st); + } + if (var_iter) { + set_del_iter (var_iter); + } + if (!var) { + // void call or return value ignored, still have to call + operands[2] = make_operand (dag, block, dagnode, 2); + st = build_statement ("call", operands, dagnode->label->expr); + sblock_add_statement (block, st); + } + return dst; +} + static operand_t * generate_assignments (dag_t *dag, sblock_t *block, operand_t *src, set_iter_t *var_iter, type_t *type) @@ -1222,8 +1259,13 @@ dag_gencode (dag_t *dag, sblock_t *block, dagnode_t *dagnode) case st_ptrmemset: dst = generate_memsetps (dag, block, dagnode); break; - case st_state: case st_func: + if (!strcmp (dagnode->label->opcode, "call")) { + dst = generate_call (dag, block, dagnode); + break; + } + // fallthrough + case st_state: for (i = 0; i < 3; i++) if (dagnode->children[i]) operands[i] = make_operand (dag, block, dagnode, i); diff --git a/tools/qfcc/source/flow.c b/tools/qfcc/source/flow.c index 4b501c027..4592ae8b6 100644 --- a/tools/qfcc/source/flow.c +++ b/tools/qfcc/source/flow.c @@ -1290,6 +1290,9 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, flow_add_op_var (def, s->opc, 0); // don't want old argument processing calln = -1; + if (operands && s->opc->op_type != op_value) { + operands[0] = s->opc; + } } else if (strncmp (s->opcode, "call", 4) == 0) { start = 0; calln = s->opcode[5] - '0'; From 0211b6ec5b19ece03a7a71fb0cfabb103e09a32f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 2 Feb 2022 14:47:36 +0900 Subject: [PATCH 300/360] [gamecode] Add 64-bit load/store instructions Only widths 3 and 4 have been added because widths 1 and 2 can be implemented by widths 2 and 4 of the 32-bit load/store instructions. --- libs/gamecode/opcodes.py | 35 +++++++++- libs/gamecode/pr_exec.c | 26 ++++++++ libs/gamecode/test/Makemodule.am | 12 ++++ libs/gamecode/test/test-load64.c | 89 +++++++++++++++++++++++++ libs/gamecode/test/test-store64.c | 105 ++++++++++++++++++++++++++++++ 5 files changed, 266 insertions(+), 1 deletion(-) create mode 100644 libs/gamecode/test/test-load64.c create mode 100644 libs/gamecode/test/test-store64.c diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 61ad591ab..3aa2ec324 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -9,7 +9,9 @@ bitmap_txt = """ 0 0000 0001 adjstk 0 0000 0010 constant 0 1011 nnnn -0 1111 nnnn +0 1111 s0mm load64 +0 1111 s1mm store64 +0 1111 n000 1 0ooo ttss mathops 1 011r tuss shiftops @@ -211,6 +213,20 @@ jump_formats = { "jump_widths": [ "0, 0", "1, 1", "1, 0", "1, 1" ] }, } +load64_formats = { + "opcode": "OP_LOAD64_{op_mode[mm]}_{s+3}", + "mnemonic": "load64", + "opname": "load64", + "format": "{load_fmt[mm]}, %gc", + "widths": "{load_widths[s+2][mm]}, {s+3}", + "types": "{load_types[mm]}, ev_void", + "args": { + "op_mode": address_mode, + "load_fmt": load_fmt, + "load_types": address_types, + "load_widths": address_widths, + }, +} lea_formats = { "opcode": "OP_LEA_{op_mode[mm]}", "mnemonic": "lea", @@ -401,6 +417,21 @@ store_formats = { "store_widths": address_widths, }, } +store64_formats = { + "opcode": "OP_STORE64_{op_mode[mm]}_{s+3}", + "mnemonic": "{store_op[mm]}64", + "opname": "{store_op[mm]}64", + "format": "%Gc, {store_fmt[mm]}", + "widths": "{store_widths[s+2][mm]}, {s+3}", + "types": "{store_types[mm]}, ev_void", + "args": { + "op_mode": address_mode, + "store_fmt": store_fmt, + "store_op": ["assign", "store", "store", "store"], + "store_types": address_types, + "store_widths": address_widths, + }, +} string_formats = { "opcode": "OP_{op_str[o*4+oo].upper()}_S", "mnemonic": "{op_str[o*4+oo]}.s", @@ -509,6 +540,7 @@ group_map = { "jump": jump_formats, "lea": lea_formats, "load": load_formats, + "load64": load64_formats, "mathops": mathops_formats, "memset": memset_formats, "move": move_formats, @@ -520,6 +552,7 @@ group_map = { "statef": statef_formats, "stated": stated_formats, "store": store_formats, + "store64": store64_formats, "string": string_formats, "swizzle": swizzle_formats, "return": return_formats, diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 89890908f..febb93266 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -2978,6 +2978,32 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) // 0 1110 OP_cmp(LE, <=); // 0 1111 + case OP_LOAD64_B_3: + case OP_LOAD64_C_3: + case OP_LOAD64_D_3: + mm = pr_address_mode (pr, st, (st_op - OP_LOAD64_B_3 + 1)); + VectorCopy (&MM(long), &OPC(long)); + break; + case OP_STORE64_A_3: + case OP_STORE64_B_3: + case OP_STORE64_C_3: + case OP_STORE64_D_3: + mm = pr_address_mode (pr, st, (st_op - OP_STORE64_A_3)); + VectorCopy (&OPC(long), &MM(long)); + break; + case OP_LOAD64_B_4: + case OP_LOAD64_C_4: + case OP_LOAD64_D_4: + mm = pr_address_mode (pr, st, (st_op - OP_LOAD64_B_4 + 1)); + OPC(lvec4) = MM(lvec4); + break; + case OP_STORE64_A_4: + case OP_STORE64_B_4: + case OP_STORE64_C_4: + case OP_STORE64_D_4: + mm = pr_address_mode (pr, st, (st_op - OP_STORE64_A_4)); + MM(lvec4) = OPC(lvec4); + break; // spare #define OP_op_1(OP, T, t, op) \ diff --git a/libs/gamecode/test/Makemodule.am b/libs/gamecode/test/Makemodule.am index 1fd3353bf..57793aa4f 100644 --- a/libs/gamecode/test/Makemodule.am +++ b/libs/gamecode/test/Makemodule.am @@ -17,12 +17,14 @@ libs_gamecode_tests = \ libs/gamecode/test/test-jump \ libs/gamecode/test/test-lea \ libs/gamecode/test/test-load \ + libs/gamecode/test/test-load64 \ libs/gamecode/test/test-long \ libs/gamecode/test/test-mem \ libs/gamecode/test/test-scale \ libs/gamecode/test/test-stack \ libs/gamecode/test/test-state \ libs/gamecode/test/test-store \ + libs/gamecode/test/test-store64 \ libs/gamecode/test/test-string \ libs/gamecode/test/test-swizzle \ libs/gamecode/test/test-unsigned \ @@ -129,6 +131,11 @@ libs_gamecode_test_test_load_SOURCES= \ libs_gamecode_test_test_load_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_load_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_load64_SOURCES= \ + libs/gamecode/test/test-load64.c +libs_gamecode_test_test_load64_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_load64_DEPENDENCIES=$(test_gamecode_libs) + libs_gamecode_test_test_long_SOURCES= \ libs/gamecode/test/test-long.c libs_gamecode_test_test_long_LDADD= $(test_gamecode_libs) @@ -158,6 +165,11 @@ libs_gamecode_test_test_store_SOURCES= \ libs_gamecode_test_test_store_LDADD= $(test_gamecode_libs) libs_gamecode_test_test_store_DEPENDENCIES= $(test_gamecode_libs) +libs_gamecode_test_test_store64_SOURCES= \ + libs/gamecode/test/test-store64.c +libs_gamecode_test_test_store64_LDADD= $(test_gamecode_libs) +libs_gamecode_test_test_store64_DEPENDENCIES= $(test_gamecode_libs) + libs_gamecode_test_test_string_SOURCES= \ libs/gamecode/test/test-string.c libs_gamecode_test_test_string_LDADD= $(test_gamecode_libs) diff --git a/libs/gamecode/test/test-load64.c b/libs/gamecode/test/test-load64.c new file mode 100644 index 000000000..abb6052eb --- /dev/null +++ b/libs/gamecode/test/test-load64.c @@ -0,0 +1,89 @@ +#include "head.c" + +static pr_int_t test_globals_init[] = { + // pointers + 24, 26, 48, 29, + 32, -8, -4, 0, + 2, 8, 0xdeadbeef, 0xfeedf00d, + 0xdeadbeef, 0xfeedf00d, 0xdeadbeef, 0xfeedf00d, + // destination data + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + // source data + 21, 22, 23, 24, 17, 18, 19, 20, + 15, 16, 9, 10, 11, 12, 13, 14, + 1, 2, 3, 4, 5, 6, 7, 8, +}; + +static pr_int_t test_globals_expect[] = { + // pointers + 24, 26, 48, 29, + 32, -8, -4, 0, + 2, 8, 0xdeadbeef, 0xfeedf00d, + 0xdeadbeef, 0xfeedf00d, 0xdeadbeef, 0xfeedf00d, + // destination data +/*16*/ 1, 2, 3, 4, 5, 6, 7, 8, +/*24*/ 9, 10, 11, 12, 13, 14, 15, 16, +/*32*/ 17, 18, 19, 20, 21, 22, 23, 24, + // source data +/*40*/ 21, 22, 23, 24, 17, 18, 19, 20, +/*48*/ 15, 16, 9, 10, 11, 12, 13, 14, +/*56*/ 1, 2, 3, 4, 5, 6, 7, 8, +}; + +static dstatement_t load64_B_statements[] = { + {OP(0, 0, 0, OP_LOAD64_B_4), 7, 9, 16}, + {OP(0, 0, 0, OP_LOAD64_B_3), 7, 8, 24}, + {OP(0, 0, 0, OP_LOAD_B_2), 7, 7, 30}, + {OP(0, 0, 0, OP_LOAD_B_4), 7, 6, 32}, + {OP(0, 0, 0, OP_LOAD_B_4), 7, 5, 36}, +}; + +static dstatement_t load64_C_statements[] = { + {OP(0, 0, 0, OP_LOAD64_C_4), 2, 8, 16}, + {OP(0, 0, 0, OP_LOAD64_C_3), 2, 2, 24}, + {OP(0, 0, 0, OP_LOAD_C_2), 2, 0, 30}, + {OP(0, 0, 0, OP_LOAD_C_4), 2, -4, 32}, + {OP(0, 0, 0, OP_LOAD_C_4), 2, -8, 36}, +}; + +static dstatement_t load64_D_statements[] = { + {OP(0, 0, 0, OP_LOAD64_D_4), 2, 9, 16}, + {OP(0, 0, 0, OP_LOAD64_D_3), 2, 8, 24}, + {OP(0, 0, 0, OP_LOAD_D_2), 2, 7, 30}, + {OP(0, 0, 0, OP_LOAD_D_4), 2, 6, 32}, + {OP(0, 0, 0, OP_LOAD_D_4), 2, 5, 36}, +}; + +test_t tests[] = { + { + .desc = "load64 B", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (load64_B_statements), + .statements = load64_B_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + // FIXME negative field offsets are not official but work because all + // offset calculations are done in 32-bit and thus wrap anyway + .edict_area = 48, + }, + { + .desc = "load64 C", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (load64_C_statements), + .statements = load64_C_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "load64 D", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (load64_D_statements), + .statements = load64_D_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, +}; + +#include "main.c" diff --git a/libs/gamecode/test/test-store64.c b/libs/gamecode/test/test-store64.c new file mode 100644 index 000000000..d8dfd2018 --- /dev/null +++ b/libs/gamecode/test/test-store64.c @@ -0,0 +1,105 @@ +#include "head.c" + +static pr_int_t test_globals_init[] = { + // pointers + 24, 26, 48, 29, + 32, -8, -4, 0, + 2, 8, 0xdeadbeef, 0xfeedf00d, + 0xdeadbeef, 0xfeedf00d, 0xdeadbeef, 0xfeedf00d, + // source data +/*16*/ 1, 2, 3, 4, 5, 6, 7, 8, +/*24*/ 9, 10, 11, 12, 13, 14, 15, 16, +/*32*/ 17, 18, 19, 20, 21, 22, 23, 24, + // destination data + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, +}; + +static pr_int_t test_globals_expect[] = { + // pointers + 24, 26, 48, 29, + 32, -8, -4, 0, + 2, 8, 0xdeadbeef, 0xfeedf00d, + 0xdeadbeef, 0xfeedf00d, 0xdeadbeef, 0xfeedf00d, + // source data +/*16*/ 1, 2, 3, 4, 5, 6, 7, 8, +/*24*/ 9, 10, 11, 12, 13, 14, 15, 16, +/*32*/ 17, 18, 19, 20, 21, 22, 23, 24, + // destination data +/*40*/ 21, 22, 23, 24, 17, 18, 19, 20, +/*48*/ 15, 16, 9, 10, 11, 12, 13, 14, +/*56*/ 1, 2, 3, 4, 5, 6, 7, 8, +}; + +static dstatement_t store64_A_statements[] = { + {OP(0, 0, 0, OP_STORE64_A_4), 56, 0, 16}, + {OP(0, 0, 0, OP_STORE64_A_3), 50, 0, 24}, + {OP(0, 0, 0, OP_STORE_A_2), 48, 0, 30}, + {OP(0, 0, 0, OP_STORE_A_4), 44, 0, 32}, + {OP(0, 0, 0, OP_STORE_A_4), 40, 0, 36}, +}; + +static dstatement_t store64_B_statements[] = { + {OP(0, 0, 0, OP_STORE64_B_4), 7, 9, 16}, + {OP(0, 0, 0, OP_STORE64_B_3), 7, 8, 24}, + {OP(0, 0, 0, OP_STORE_B_2), 7, 7, 30}, + {OP(0, 0, 0, OP_STORE_B_4), 7, 6, 32}, + {OP(0, 0, 0, OP_STORE_B_4), 7, 5, 36}, +}; + +static dstatement_t store64_C_statements[] = { + {OP(0, 0, 0, OP_STORE64_C_4), 2, 8, 16}, + {OP(0, 0, 0, OP_STORE64_C_3), 2, 2, 24}, + {OP(0, 0, 0, OP_STORE_C_2), 2, 0, 30}, + {OP(0, 0, 0, OP_STORE_C_4), 2, -4, 32}, + {OP(0, 0, 0, OP_STORE_C_4), 2, -8, 36}, +}; + +static dstatement_t store64_D_statements[] = { + {OP(0, 0, 0, OP_STORE64_D_4), 2, 9, 16}, + {OP(0, 0, 0, OP_STORE64_D_3), 2, 8, 24}, + {OP(0, 0, 0, OP_STORE_D_2), 2, 7, 30}, + {OP(0, 0, 0, OP_STORE_D_4), 2, 6, 32}, + {OP(0, 0, 0, OP_STORE_D_4), 2, 5, 36}, +}; + +test_t tests[] = { + { + .desc = "store64 A", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (store64_A_statements), + .statements = store64_A_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "store64 B", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (store64_B_statements), + .statements = store64_B_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + // FIXME negative field offsets are not official but work because all + // offset calculations are done in 32-bit and thus wrap anyway + .edict_area = 48, + }, + { + .desc = "store64 C", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (store64_C_statements), + .statements = store64_C_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, + { + .desc = "store64 D", + .num_globals = num_globals (test_globals_init, test_globals_expect), + .num_statements = num_statements (store64_D_statements), + .statements = store64_D_statements, + .init_globals = test_globals_init, + .expect_globals = test_globals_expect, + }, +}; + +#include "main.c" From 38550922cc4e980427be8339354d1b9193318065 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 2 Feb 2022 16:06:15 +0900 Subject: [PATCH 301/360] [qfcc] Map 64-bit load/store/assign instructions In order to not waste instructions, the Ruamoko ISA does not provide 1 and 2 component 64-bit load/store instructions since they can be implemented using 2 and 4 component 32-bit instructions (load and store are independent of the interpretation of the data). This fixes the double test, and technically the double-alias test, but it fails due to a problem with the optimizer causing lea to use the wrong reference for the address. It also breaks the quaternion test due to what seems to be a type error that may have been lurking for a while, further investigation is needed there. --- tools/qfcc/source/opcodes.c | 45 +++++++++++++++++++++++++++++++++---- tools/qfcc/test/double.r | 2 +- 2 files changed, 42 insertions(+), 5 deletions(-) diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index dcb6342cc..4be436c1b 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -280,7 +280,7 @@ operand_type (const operand_t *op, const char *name) } static int -operand_width (operand_t *op) +operand_width (const char *opname, operand_t *op) { if (!op) { return 0; @@ -292,6 +292,14 @@ operand_width (operand_t *op) if (type == ev_quaternion) { return 4; } + // FIXME see FIXME in rua_opcode_find + if ((type == ev_long || type == ev_ulong || type == ev_double) + && (!strcmp (opname, "load") || !strcmp (opname, "store") + || !strcmp (opname, "assign"))) { + if (op->width < 3) { + return op->width * 2; + } + } return op->width; } @@ -299,6 +307,35 @@ static opcode_t * rua_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, operand_t *op_c) { + // FIXME this is a bit of an ugly hack to map 64-bit load and store/assign + // instructions: 1 and 2 component instructions become 2 and 4 components + // using the 32-bit instructions, while 3 and 4 remain unchanged but use + // the 64-bit versions of the instructs (of which there are only 3 and 4 + // component versions). That bit of fun can't be helped without wasting a + // lot of instructions, but this mapping scheme leaves a lot to be desired. + const char *opname_a = ""; + const char *opname_c = ""; + if (!strcmp (name, "load") || !strcmp (name, "store") + || !strcmp (name, "assign")) { + opname_c = name; + if (!strcmp (name, "assign")) { + opname_a = name; + if (op_c->width > 2) { + name = "assign64"; + } + } + if (!strcmp (name, "load")) { + if (op_c->width > 2) { + name = "load64"; + } + } + if (!strcmp (name, "store")) { + if (op_c->width > 2) { + name = "store64"; + } + } + } + opcode_t search_op = { .opname = name, .types = { @@ -307,9 +344,9 @@ rua_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, operand_type (op_c, name), }, .widths = { - operand_width (op_a), - operand_width (op_b), - operand_width (op_c), + operand_width (opname_a, op_a), + operand_width ("", op_b), + operand_width (opname_c, op_c), }, }; opcode_t *op; diff --git a/tools/qfcc/test/double.r b/tools/qfcc/test/double.r index 326ccf906..de0649b19 100644 --- a/tools/qfcc/test/double.r +++ b/tools/qfcc/test/double.r @@ -11,7 +11,7 @@ test_format () { int fail = 0; type_pun.d = M_PI; - printf ("%g %08x%08x\n", type_pun.d, type_pun.i[1], type_pun.i[0]); + printf ("%.17g %08x%08x\n", type_pun.d, type_pun.i[1], type_pun.i[0]); // this will fail on big-endian systems fail = type_pun.i[0] != 0x54442d18 || type_pun.i[1] != 0x400921fb; return fail; From a64f91129f4a87a340bf27963fc0e8920c982d4c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 2 Feb 2022 18:55:01 +0900 Subject: [PATCH 302/360] [qfcc] Give lea its own statement type This makes it much easier to check (and more robust to name changes), allowing for effectively killing the node to which the variable being addressed is attached. This fixes the incorrect address being used for va_list, which is what caused double-alias to fail. --- tools/qfcc/include/statements.h | 1 + tools/qfcc/source/dags.c | 6 +++++- tools/qfcc/source/flow.c | 20 +++++++++++++------- tools/qfcc/source/statements.c | 7 ++++--- 4 files changed, 23 insertions(+), 11 deletions(-) diff --git a/tools/qfcc/include/statements.h b/tools/qfcc/include/statements.h index 3bee3de33..a1fc6914e 100644 --- a/tools/qfcc/include/statements.h +++ b/tools/qfcc/include/statements.h @@ -102,6 +102,7 @@ typedef enum { st_state, ///< state (a, b); or state (a, b, c) st_func, ///< call, rcall or return/done st_flow, ///< if/ifa/ifae/ifb/ifbe/ifnot or goto or jump/jumpb + st_address, ///< lea } st_type_t; typedef struct statement_s { diff --git a/tools/qfcc/source/dags.c b/tools/qfcc/source/dags.c index e55688ff4..d2f746962 100644 --- a/tools/qfcc/source/dags.c +++ b/tools/qfcc/source/dags.c @@ -282,8 +282,11 @@ dag_make_children (dag_t *dag, statement_t *s, dagnode_t *node = dag_node (operands[i + 1]); dagnode_t *killer = 0; - if (node && node->killed) { + if (node && (node->killed || s->type == st_address)) { // If the node has been killed, then a new node is needed + // taking the address of a variable effectively kills the node it's + // attached to. FIXME should this be for only when the variable is + // in the attached identifiers list and is not the node's label? killer = node->killed; node = 0; } @@ -1214,6 +1217,7 @@ dag_gencode (dag_t *dag, sblock_t *block, dagnode_t *dagnode) dst = generate_assignments (dag, block, dst, var_iter, type); } break; + case st_address: case st_expr: operands[0] = make_operand (dag, block, dagnode, 0); if (dagnode->children[1]) diff --git a/tools/qfcc/source/flow.c b/tools/qfcc/source/flow.c index 4592ae8b6..4e86fc0c3 100644 --- a/tools/qfcc/source/flow.c +++ b/tools/qfcc/source/flow.c @@ -1181,15 +1181,21 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill, switch (s->type) { case st_none: internal_error (s->expr, "not a statement"); + case st_address: + if (s->opb) { + flow_add_op_var (use, s->opa, 1); + flow_add_op_var (use, s->opb, 1); + } + flow_add_op_var (def, s->opc, 0); + if (operands) { + operands[0] = s->opc; + operands[1] = s->opa; + operands[2] = s->opb; + } + break; case st_expr: flow_add_op_var (def, s->opc, 0); - if (strcmp (s->opcode, "lea") == 0) { - if (s->opb) { - flow_add_op_var (use, s->opa, 1); - } - } else { - flow_add_op_var (use, s->opa, 1); - } + flow_add_op_var (use, s->opa, 1); if (s->opb) flow_add_op_var (use, s->opb, 1); if (operands) { diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index bfa782205..e75d4c676 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -87,6 +87,7 @@ const char *st_type_names[] = { "st_state", "st_func", "st_flow", + "st_address", }; const char * @@ -744,7 +745,7 @@ expr_address (sblock_t *sblock, expr_t *e, operand_t **op) offset = 0; } - s = new_statement (st_expr, "lea", e); + s = new_statement (st_address, "lea", e); sblock = statement_subexpr (sblock, lvalue, &s->opa); if (offset) { sblock = statement_subexpr (sblock, offset, &s->opb); @@ -1005,7 +1006,7 @@ dereference_dst: // one directly. FIXME it was probably a mistake extracting the operand // type from the statement expression in dags dst_expr = expr_file_line (address_expr (dst_expr, 0), dst_expr); - s = new_statement (st_expr, "lea", dst_expr); + s = new_statement (st_address, "lea", dst_expr); s->opa = dst; s->opb = ofs; s->opc = temp_operand (&type_ptr, dst_expr); @@ -1438,7 +1439,7 @@ statement_with (sblock_t *sblock, expr_t *e) static statement_t * lea_statement (operand_t *pointer, operand_t *offset, expr_t *e) { - statement_t *s = new_statement (st_expr, "lea", e); + statement_t *s = new_statement (st_address, "lea", e); s->opa = pointer; s->opb = offset; s->opc = temp_operand (&type_ptr, e); From 0fa9d0d256d3f24bdf87bec07b6cb848da24b7a2 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 2 Feb 2022 19:04:43 +0900 Subject: [PATCH 303/360] [qfcc] Tweak the printf to make more sense Though I'm sure I had a good reason at the time, seeing 6.98487e-315 when expecting pi is a bit disconcerting. --- tools/qfcc/test/double-alias.r | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/qfcc/test/double-alias.r b/tools/qfcc/test/double-alias.r index 92eecd9c3..5df0d3398 100644 --- a/tools/qfcc/test/double-alias.r +++ b/tools/qfcc/test/double-alias.r @@ -25,8 +25,8 @@ alias_printf (string fmt, ...) // this will fail on big-endian systems fail = (@args.list[2].int_val != 0x54442d18 || @args.list[1].int_val != 0x400921fb); - printf ("%g %08x%08x\n", - @args.list[0].int_val, + printf ("%.17g %08x%08x\n", + @args.list[0].double_val, @args.list[2].int_val, @args.list[1].int_val); return fail; From 6fe72b0420d2b45a2119c21e919c134db6b9d94f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 2 Feb 2022 19:14:22 +0900 Subject: [PATCH 304/360] [qfcc] Check load/store operand type before mangling This fixes the incorrect use of assign64 for quaternions. All tests except return-postop pass \o/. --- tools/qfcc/source/opcodes.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/tools/qfcc/source/opcodes.c b/tools/qfcc/source/opcodes.c index 4be436c1b..5c97f780c 100644 --- a/tools/qfcc/source/opcodes.c +++ b/tools/qfcc/source/opcodes.c @@ -315,8 +315,11 @@ rua_opcode_find (const char *name, operand_t *op_a, operand_t *op_b, // lot of instructions, but this mapping scheme leaves a lot to be desired. const char *opname_a = ""; const char *opname_c = ""; - if (!strcmp (name, "load") || !strcmp (name, "store") - || !strcmp (name, "assign")) { + etype_t type; + if ((!strcmp (name, "load") || !strcmp (name, "store") + || !strcmp (name, "assign")) + && ((type = low_level_type (op_c->type)) == ev_long + || type == ev_ulong || type == ev_double)) { opname_c = name; if (!strcmp (name, "assign")) { opname_a = name; From b668759b7dee16a88e53441d43b7a1142f6d568b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Wed, 2 Feb 2022 23:51:37 +0900 Subject: [PATCH 305/360] [qfcc] Add a very basic attribute system Ruamoko passes va_list (@args) through the ... parameter (as such), but IMP uses ... to defeat parameter type and count checking and doesn't want va_list. While possibly not the best solution, adding a no_va_list flag to function types and skipping ex_args entirely does take care of the problem without hard-coding anything specific to IMP. The system currently just sets some bits in the type specifier (the attribute list should probably be carried around with the specifier), but it gets the job done for now, and at least gets things started. --- tools/qfcc/include/Makemodule.am | 1 + tools/qfcc/include/attribute.h | 43 +++++++++++++++++++++++++ tools/qfcc/include/type.h | 2 ++ tools/qfcc/source/Makemodule.am | 1 + tools/qfcc/source/attribute.c | 55 ++++++++++++++++++++++++++++++++ tools/qfcc/source/class.c | 2 +- tools/qfcc/source/expr.c | 2 +- tools/qfcc/source/qc-lex.l | 4 +-- tools/qfcc/source/qc-parse.y | 52 +++++++++++++++++++++++++++--- tools/qfcc/source/type.c | 3 +- tools/qfcc/test/chewed-alias.r | 2 +- tools/qfcc/test/methodparams.r | 2 +- tools/qfcc/test/sendv.r | 2 +- 13 files changed, 159 insertions(+), 12 deletions(-) create mode 100644 tools/qfcc/include/attribute.h create mode 100644 tools/qfcc/source/attribute.c diff --git a/tools/qfcc/include/Makemodule.am b/tools/qfcc/include/Makemodule.am index 689ebad68..f6158b5c4 100644 --- a/tools/qfcc/include/Makemodule.am +++ b/tools/qfcc/include/Makemodule.am @@ -1,4 +1,5 @@ EXTRA_DIST += \ + tools/qfcc/include/attribute.h \ tools/qfcc/include/class.h \ tools/qfcc/include/codespace.h \ tools/qfcc/include/cpp.h \ diff --git a/tools/qfcc/include/attribute.h b/tools/qfcc/include/attribute.h new file mode 100644 index 000000000..2f47642e6 --- /dev/null +++ b/tools/qfcc/include/attribute.h @@ -0,0 +1,43 @@ +/* + attribute.h + + Attribute list handling + + Copyright (C) 2022 Bill Currie + + Author: Bill Currie + Date: 2022/02/02 + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + +*/ + +#ifndef attribute_h +#define attribute_h + +typedef struct attribute_s { + struct attribute_s *next; + const char *name; + struct ex_value_s *value; +} attribute_t; + +struct expr_s; +attribute_t *new_attribute(const char *name, struct expr_s *value); + +#endif//attribute_h diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h index 2062933d6..7a213dd98 100644 --- a/tools/qfcc/include/type.h +++ b/tools/qfcc/include/type.h @@ -39,6 +39,7 @@ typedef struct ty_func_s { struct type_s *type; int num_params; struct type_s **param_types; + int no_va_list; ///< don't inject va_list for ... function } ty_func_t; typedef struct ty_fldptr_s { @@ -97,6 +98,7 @@ typedef struct { unsigned is_typedef:1; unsigned is_overload:1; unsigned nosave:1; + unsigned no_va_list:1; } specifier_t; #define EV_TYPE(type) extern type_t type_##type; diff --git a/tools/qfcc/source/Makemodule.am b/tools/qfcc/source/Makemodule.am index 76e3f73d8..d7d85e597 100644 --- a/tools/qfcc/source/Makemodule.am +++ b/tools/qfcc/source/Makemodule.am @@ -7,6 +7,7 @@ bin_PROGRAMS += @QFCC_TARGETS@ bin_SCRIPTS += tools/qfcc/source/qfpreqcc qfcc_SOURCES = \ + tools/qfcc/source/attribute.c \ tools/qfcc/source/class.c \ tools/qfcc/source/codespace.c \ tools/qfcc/source/constfold.c \ diff --git a/tools/qfcc/source/attribute.c b/tools/qfcc/source/attribute.c new file mode 100644 index 000000000..b821124c1 --- /dev/null +++ b/tools/qfcc/source/attribute.c @@ -0,0 +1,55 @@ +/* + attribute.c + + Attribute list handling + + Copyright (C) 2022 Bill Currie + + Author: Bill Currie + Date: 2022/02/02 + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License + as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + This program 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 General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + +*/ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "QF/alloc.h" + +#include "tools/qfcc/include/attribute.h" +#include "tools/qfcc/include/diagnostic.h" +#include "tools/qfcc/include/expr.h" +#include "tools/qfcc/include/strpool.h" + +static attribute_t *attributes_freelist; + +attribute_t *new_attribute(const char *name, expr_t *value) +{ + if (value && value->type != ex_value) { + error (value, "not a literal constant"); + return 0; + } + + attribute_t *attr; + ALLOC (16384, attribute_t, attributes, attr); + attr->name = save_string (name); + attr->value = value ? value->e.value : 0; + return attr; +} diff --git a/tools/qfcc/source/class.c b/tools/qfcc/source/class.c index d90ecc062..42f613c9e 100644 --- a/tools/qfcc/source/class.c +++ b/tools/qfcc/source/class.c @@ -90,7 +90,7 @@ type_t type_IMP = { .alignment = 1, .width = 1, .meta = ty_basic, - {{&type_id, -3, IMP_params}}, + {{&type_id, -3, IMP_params, 1}}, }; type_t type_super = { .type = ev_invalid, diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 7af72d5a1..3364bedbf 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -2155,7 +2155,7 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) warning (fexpr, "too few arguments"); } param_count = -ftype->t.func.num_params - 1; - emit_args = 1; + emit_args = !ftype->t.func.no_va_list; } else if (ftype->t.func.num_params >= 0) { if (arg_count > ftype->t.func.num_params) { return error (fexpr, "too many arguments"); diff --git a/tools/qfcc/source/qc-lex.l b/tools/qfcc/source/qc-lex.l index c2db6db0c..3c8e28ec9 100644 --- a/tools/qfcc/source/qc-lex.l +++ b/tools/qfcc/source/qc-lex.l @@ -367,7 +367,6 @@ static keyword_t at_keywords[] = { {"extern", EXTERN }, {"static", STATIC }, {"sizeof", SIZEOF }, - {"nosave", NOSAVE }, {"not", NOT }, }; @@ -391,7 +390,7 @@ static keyword_t qf_keywords[] = { {"@dot", DOT, 0 }, }; -// These keywors are always available. Other than @system and @overload, they +// These keywors are always available. Other than the @ keywords, they // form traditional QuakeC. static keyword_t keywords[] = { {"void", TYPE, &type_void }, @@ -407,6 +406,7 @@ static keyword_t keywords[] = { {"else", ELSE, 0 }, {"@system", SYSTEM, 0 }, {"@overload", OVERLOAD, 0 }, + {"@attribute", ATTRIBUTE, 0 }, }; static const char * diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index 3ab14cbe2..99006c68e 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -44,6 +44,7 @@ #include #include +#include "tools/qfcc/include/attribute.h" #include "tools/qfcc/include/class.h" #include "tools/qfcc/include/debug.h" #include "tools/qfcc/include/def.h" @@ -112,6 +113,7 @@ int yylex (void); struct methodlist_s *methodlist; struct symbol_s *symbol; struct symtab_s *symtab; + struct attribute_s *attribute; } // these tokens are common between qc and qp @@ -149,7 +151,7 @@ int yylex (void); %token LOCAL RETURN WHILE DO IF ELSE FOR BREAK CONTINUE ELLIPSIS %token NIL GOTO SWITCH CASE DEFAULT ENUM -%token ARGS TYPEDEF EXTERN STATIC SYSTEM NOSAVE OVERLOAD NOT +%token ARGS TYPEDEF EXTERN STATIC SYSTEM OVERLOAD NOT ATTRIBUTE %token UNSIGNED SIGNED LONG SHORT %token STRUCT %token TYPE @@ -162,6 +164,8 @@ int yylex (void); %type type_specifier type_specifier_or_storage_class %type type +%type attribute_list attribute + %type function_params var_list param_declaration %type qc_func_params qc_var_list qc_param_decl %type new_name @@ -238,6 +242,22 @@ make_spec (type_t *type, storage_class_t storage, int is_typedef, return spec; } +static specifier_t +parse_attributes (attribute_t *attr_list) +{ + specifier_t spec = {}; + for (attribute_t *attr = attr_list; attr; attr = attr->next) { + if (!strcmp (attr->name, "no_va_list")) { + spec.no_va_list = 1; + } else if (!strcmp (attr->name, "nosave")) { + spec.nosave = 1; + } else { + warning (0, "skipping unknown attribute '%s'", attr->name); + } + } + return spec; +} + static specifier_t spec_merge (specifier_t spec, specifier_t new) { @@ -276,6 +296,7 @@ spec_merge (specifier_t spec, specifier_t new) spec.is_long |= new.is_long; spec.is_overload |= new.is_overload; spec.nosave |= new.nosave; + spec.no_va_list |= new.no_va_list; return spec; } @@ -471,6 +492,7 @@ external_def ret_type = *type; *type = 0; *type = parse_params (0, $2); + (*type)->t.func.no_va_list = $1.no_va_list; $$.type = find_type (append_type ($1.type, ret_type)); if ($$.type->type != ev_field) $$.params = $2; @@ -511,6 +533,7 @@ function_body symbol_t *sym = $0; specifier_t spec = default_type ($-1, sym); + sym->type->t.func.no_va_list = spec.no_va_list; sym->type = find_type (append_type (sym->type, spec.type)); $$ = function_symbol (sym, spec.is_overload, 1); } @@ -534,6 +557,7 @@ function_body symbol_t *sym = $0; specifier_t spec = default_type ($-1, sym); + sym->type->t.func.no_va_list = spec.no_va_list; sym->type = find_type (append_type (sym->type, spec.type)); sym = function_symbol (sym, spec.is_overload, 1); build_builtin_function (sym, $3, 0, spec.storage); @@ -582,6 +606,7 @@ external_decl | function_decl { specifier_t spec = default_type ($0, $1); + $1->type->t.func.no_va_list = spec.no_va_list; $1->type = find_type (append_type ($1->type, spec.type)); if (spec.is_typedef) { $1->sy_type = sy_type; @@ -599,13 +624,30 @@ storage_class | SYSTEM { $$ = make_spec (0, sc_system, 0, 0); } | TYPEDEF { $$ = make_spec (0, sc_global, 1, 0); } | OVERLOAD { $$ = make_spec (0, current_storage, 0, 1); } - | NOSAVE + | ATTRIBUTE '(' attribute_list ')' { - $$ = make_spec (0, current_storage, 0, 0); - $$.nosave = 1; + $$ = parse_attributes ($3); } ; +attribute_list + : attribute + | attribute_list ',' attribute + { + if ($3) { + $3->next = $1; + $$ = $3; + } else { + $$ = $1; + } + } + ; + +attribute + : NAME { $$ = new_attribute ($1->name, 0); } + | NAME '(' expr_list ')' { $$ = new_attribute ($1->name, $3); } + ; + optional_specifiers : specifiers { @@ -1053,6 +1095,7 @@ qc_param_decl type = &(*type)->t.fldptr.type) ; *type = parse_params (*type, $2); + (*type)->t.func.no_va_list = $1.no_va_list; $3->type = find_type ($1.type); if ($3->type->type != ev_field) $3->params = $2; @@ -1131,6 +1174,7 @@ local_decl_list type = &(*type)->t.fldptr.type) ; *type = parse_params (*type, $1); + (*type)->t.func.no_va_list = spec.no_va_list; spec.type = find_type (spec.type); $$ = spec; } diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index 7e73fc99d..9f94affae 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -381,7 +381,8 @@ types_same (type_t *a, type_t *b) return 0; case ev_func: if (a->t.func.type != b->t.func.type - || a->t.func.num_params != b->t.func.num_params) + || a->t.func.num_params != b->t.func.num_params + || a->t.func.no_va_list != b->t.func.no_va_list) return 0; count = a->t.func.num_params; if (count < 0) diff --git a/tools/qfcc/test/chewed-alias.r b/tools/qfcc/test/chewed-alias.r index 08c060534..409254c39 100644 --- a/tools/qfcc/test/chewed-alias.r +++ b/tools/qfcc/test/chewed-alias.r @@ -18,7 +18,7 @@ int main () { return 0; // test succeeds if compile succeeds } -id obj_msgSend (id receiver, SEL op, ...) = #0; +@attribute(no_va_list) id obj_msgSend (id receiver, SEL op, ...) = #0; void __obj_exec_class (struct obj_module *msg) = #0; @implementation Object @end diff --git a/tools/qfcc/test/methodparams.r b/tools/qfcc/test/methodparams.r index b29e6954b..d2e71591b 100644 --- a/tools/qfcc/test/methodparams.r +++ b/tools/qfcc/test/methodparams.r @@ -15,7 +15,7 @@ typedef struct { int x, y; } Point; [textContext mvvprintf: pos, fmt, @args]; } @end -id obj_msgSend (id receiver, SEL op, ...) = #0; +@attribute(no_va_list) id obj_msgSend (id receiver, SEL op, ...) = #0; void __obj_exec_class (struct obj_module *msg) = #0; @interface Object @end diff --git a/tools/qfcc/test/sendv.r b/tools/qfcc/test/sendv.r index aa2cb6665..24929992a 100644 --- a/tools/qfcc/test/sendv.r +++ b/tools/qfcc/test/sendv.r @@ -54,5 +54,5 @@ main () } @end -id (id receiver, SEL op, ...) obj_msgSend = #0; +@attribute(no_va_list) id (id receiver, SEL op, ...) obj_msgSend = #0; void __obj_exec_class (struct obj_module *msg) = #0; From 6f49b919eca12be0a1606949786c290f08923835 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 3 Feb 2022 10:55:37 +0900 Subject: [PATCH 306/360] [qfcc] Move constant pointer offset into address expr This is the intended purpose of the offset field in address expressions, and will make struct and array accesses more efficient when I sort out the code generation side. --- tools/qfcc/source/expr.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 3364bedbf..7b1d76372 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -2622,6 +2622,12 @@ offset_pointer_expr (expr_t *pointer, expr_t *offset) if (pointer->type == ex_alias && !pointer->e.alias.offset && is_integral (get_type (pointer->e.alias.expr))) { ptr = pointer->e.alias.expr; + } else if (pointer->type == ex_address && is_constant (offset)) { + if (pointer->e.address.offset) { + offset = binary_expr ('+', pointer->e.address.offset, offset); + } + pointer->e.address.offset = offset; + return pointer; } else { ptr = cast_expr (&type_int, pointer); } From 80c643154475d78621a0f676fdeba81f46eb44cb Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 3 Feb 2022 14:15:20 +0900 Subject: [PATCH 307/360] [qfcc] Clear up a FIXME The FIXME was there because I couldn't remember why the test was type_compatible but the internal error complains about the types being the same size. The compatibility check is to see if the op can be used directly or whether a temp is required. The offset check is because types that are the same size (which they must be if they are compatible) is because it is not possible to create an offset alias def that escapes the bounds of the real def, which any non-zero offset will do if the types are the same size. --- tools/qfcc/source/statements.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index e75d4c676..7fed3cef0 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1532,8 +1532,9 @@ expr_alias (sblock_t *sblock, expr_t *e, operand_t **op) type = e->e.alias.type; sblock = statement_subexpr (sblock, e->e.alias.expr, &aop); if (type_compatible (aop->type, type)) { - //FIXME type_compatible??? shouldn't that be type_size ==? if (offset) { + //For types to be compatible, they must be the same size, thus this + //seemingly mismatched error internal_error (e, "offset alias of same size type"); } *op = aop; From 008359862b0bb4ab6bf68ab402e8eb6472f56bae Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 3 Feb 2022 14:35:43 +0900 Subject: [PATCH 308/360] [qfcc] Avoid pointer alias of address expressions Since address expressions always product a pointer type, aliasing one to another pointer type is redundant. Instead, simply return an address expression with the desired type. --- tools/qfcc/source/expr.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 7b1d76372..341f6d7a9 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1346,6 +1346,12 @@ is_pointer_val (expr_t *e) expr_t * new_alias_expr (type_t *type, expr_t *expr) { + if (is_ptr (type) && expr->type == ex_address) { + // avoid aliasing a pointer to a pointer (redundant) + expr = copy_expr (expr); + expr->e.address.type = type; + return expr; + } if (expr->type == ex_alias) { if (expr->e.alias.offset) { return new_offset_alias_expr (type, expr, 0); From a3c37201b2d493873578540965844323785ca467 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 3 Feb 2022 14:41:46 +0900 Subject: [PATCH 309/360] [qfcc] Emit constant pointers as direct def references When possible, of course. However, this tightens up struct and constant index array accesses, and avoids issues with flow analysis losing track of the def (such trucking is something I want to do, but haven't decided out to get the information out to the right statements). --- tools/qfcc/source/statements.c | 74 +++++++++++++++++++++++++++++----- 1 file changed, 63 insertions(+), 11 deletions(-) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 7fed3cef0..aaba453ff 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -947,7 +947,7 @@ expr_assign (sblock_t *sblock, expr_t *e, operand_t **op) operand_t *ofs = 0; pr_ushort_t mode = 0; // assign const char *opcode = "assign"; - st_type_t type; + st_type_t type = st_assign; if (src_expr->type == ex_assign) { sblock = statement_subexpr (sblock, src_expr, &src); @@ -983,15 +983,18 @@ expr_assign (sblock_t *sblock, expr_t *e, operand_t **op) sblock = statement_subexpr (sblock, src_expr, &src); } } - type = st_assign; if (0) { dereference_dst: // dst_expr is a dereferenced pointer, so need to get its addressing // parameters (base and offset) and switch to storep instructions. sblock = addressing_mode (sblock, dst_expr, &dst, &ofs, &mode); - opcode = "store"; - type = st_ptrassign; + if (mode != 0) { + opcode = "store"; + type = st_ptrassign; + } else { + ofs = 0; + } } if (op) { *op = src; @@ -1290,11 +1293,45 @@ static sblock_t * ptr_addressing_mode (sblock_t *sblock, expr_t *ref, operand_t **base, operand_t **offset, pr_ushort_t *mode) { - if (!is_ptr (get_type (ref))) { + type_t *type = get_type (ref); + if (!is_ptr (type)) { internal_error (ref, "expected pointer in ref"); } - if (ref->type != ex_alias || ref->e.alias.offset) { + if (ref->type == ex_address + && (!ref->e.address.offset || is_constant (ref->e.address.offset)) + && ref->e.address.lvalue->type == ex_alias + && (!ref->e.address.lvalue->e.alias.offset + || is_constant (ref->e.address.lvalue->e.alias.offset))) { + expr_t *lvalue = ref->e.address.lvalue; + expr_t *offs = ref->e.address.offset; + expr_t *alias; + if (lvalue->e.alias.offset) { + if (offs) { + offs = binary_expr ('+', offs, lvalue->e.alias.offset); + } else { + offs = lvalue->e.alias.offset; + } + } + type = type->t.fldptr.type; + if (offs) { + expr_t *lv = lvalue->e.alias.expr; + type_t *lvtype = get_type (lv); + int o = expr_int (offs); + if (o < 0 || o + type_size (type) > type_size (lvtype)) { + // not a valid offset for the type, which technically should + // be an error, but there may be legitimate reasons for doing + // such pointer shenanigans + goto just_a_pointer; + } + alias = new_offset_alias_expr (type, lv, expr_int (offs)); + } else { + alias = new_alias_expr (type, lvalue->e.alias.expr); + } + expr_file_line (alias, ref); + return addressing_mode (sblock, alias, base, offset, mode); + } else if (ref->type != ex_alias || ref->e.alias.offset) { // probably just a pointer +just_a_pointer: sblock = statement_subexpr (sblock, ref, base); *offset = short_operand (0, ref); *mode = 2; // mode C: ptr + constant index @@ -1468,6 +1505,15 @@ load_statement (operand_t *ptr, operand_t *offs, operand_t *op, expr_t *e) return s; } +static statement_t * +assign_statement (operand_t *dst, operand_t *src, expr_t *e) +{ + statement_t *s = new_statement (st_assign, "assign", e); + s->opa = dst; + s->opc = src; + return s; +} + static sblock_t * expr_deref (sblock_t *sblock, expr_t *deref, operand_t **op) { @@ -1476,10 +1522,21 @@ expr_deref (sblock_t *sblock, expr_t *deref, operand_t **op) operand_t *base = 0; operand_t *offset = 0; pr_ushort_t mode; + statement_t *s; sblock = addressing_mode (sblock, deref, &base, &offset, &mode); + if (!*op) { + *op = temp_operand (load_type, deref); + } + switch (mode) { + case 0://direct def access + // FIXME should check that offset is 0, but currently, + // addressing_mode always sets offset to 0 for mode 0 + s = assign_statement (*op, base, deref); + sblock_add_statement (sblock, s); + return sblock; case 1://entity.field case 2://const indexed pointer case 3://var indexed pointer @@ -1488,11 +1545,6 @@ expr_deref (sblock_t *sblock, expr_t *deref, operand_t **op) internal_error (deref, "unexpected addressing mode: %d", mode); } - if (!*op) { - *op = temp_operand (load_type, deref); - } - - statement_t *s; if (low_level_type (load_type) == ev_void) { s = lea_statement (base, offset, ptr_expr); sblock_add_statement (sblock, s); From 3d8ee5df438afb41b5a71739d5c8eb3cb4bf97a9 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Thu, 3 Feb 2022 16:33:42 +0900 Subject: [PATCH 310/360] [qfcc] Ensure ops on globals occur before return This fixes the return-postop test, and covers calls, too. --- tools/qfcc/source/dags.c | 14 +++++++++++++- tools/qfcc/test/Makemodule.am | 3 +-- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/tools/qfcc/source/dags.c b/tools/qfcc/source/dags.c index d2f746962..6c787fdc6 100644 --- a/tools/qfcc/source/dags.c +++ b/tools/qfcc/source/dags.c @@ -462,7 +462,8 @@ dagnode_set_edges (dag_t *dag, dagnode_t *n, statement_t *s) if (n->type == st_func) { const char *num_params = 0; int first_param = 0; - flowvar_t **flowvars = dag->flownode->graph->func->vars; + function_t *func = dag->flownode->graph->func; + flowvar_t **flowvars = func->vars; if (!strcmp (n->label->opcode, "call")) { // nothing to do @@ -482,6 +483,17 @@ dagnode_set_edges (dag_t *dag, dagnode_t *n, statement_t *s) } label->live = 1; } + // ensure all operantions on global variables are completed before + // the st_func statement executes + for (set_iter_t *g = set_first (func->global_vars); g; + g = set_next (g)) { + flowvar_t *var = flowvars[g->element]; + dagnode_t *gn = dag_node (var->op); + if (gn) { + set_add (n->edges, gn->number); + set_remove (gn->edges, n->number); + } + } if (num_params && isdigit (*num_params)) { for (i = first_param; i < *num_params - '0'; i++) { flowvar_t *var = flowvars[i + 1]; diff --git a/tools/qfcc/test/Makemodule.am b/tools/qfcc/test/Makemodule.am index c82d750c4..f5111177e 100644 --- a/tools/qfcc/test/Makemodule.am +++ b/tools/qfcc/test/Makemodule.am @@ -68,8 +68,7 @@ test_progs_dat=\ tools/qfcc/test/while.dat \ tools/qfcc/test/zerolinker.dat -fail_progs_dat=\ - tools/qfcc/test/return-postop.dat +fail_progs_dat= test_build_errors=\ tools/qfcc/test/classarray.r \ From 1487fa6b5058562ec3d7cbee6cb87070949fc45c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 00:25:31 +0900 Subject: [PATCH 311/360] [qfcc] Implement some basics for the vector types They're now properly part of the type system and can be used for declaring variables, initialized (using {} block initializers), operated on (=, *, + tested) though much work needs to be done on binary expressions, and indexed. So far, only ivec2 has been tested. --- tools/qfcc/include/type.h | 7 ++-- tools/qfcc/include/vec_types.h | 24 ++++++++++++++ tools/qfcc/source/def.c | 2 +- tools/qfcc/source/expr.c | 37 +++++++++++++++------ tools/qfcc/source/expr_binary.c | 10 ++++++ tools/qfcc/source/expr_compound.c | 53 ++++++++++++++++++++----------- tools/qfcc/source/qc-lex.l | 24 +++++++++++--- tools/qfcc/source/type.c | 46 +++++++++++++++------------ 8 files changed, 146 insertions(+), 57 deletions(-) create mode 100644 tools/qfcc/include/vec_types.h diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h index 7a213dd98..cafa1da91 100644 --- a/tools/qfcc/include/type.h +++ b/tools/qfcc/include/type.h @@ -104,10 +104,8 @@ typedef struct { #define EV_TYPE(type) extern type_t type_##type; #include "QF/progs/pr_type_names.h" -extern type_t type_ivec3; -extern type_t type_ivec4; -extern type_t type_vec3; -extern type_t type_vec4; +#define VEC_TYPE(type_name, base_type) extern type_t type_##type_name; +#include "tools/qfcc/include/vec_types.h" extern type_t type_invalid; extern type_t type_floatfield; @@ -167,6 +165,7 @@ const char *type_get_encoding (const type_t *type); int is_enum (const type_t *type) __attribute__((pure)); int is_integral (const type_t *type) __attribute__((pure)); +int is_real (const type_t *type) __attribute__((pure)); int is_scalar (const type_t *type) __attribute__((pure)); int is_nonscalar (const type_t *type) __attribute__((pure)); int is_math (const type_t *type) __attribute__((pure)); diff --git a/tools/qfcc/include/vec_types.h b/tools/qfcc/include/vec_types.h new file mode 100644 index 000000000..4931c8d09 --- /dev/null +++ b/tools/qfcc/include/vec_types.h @@ -0,0 +1,24 @@ +#ifndef VEC_TYPE +#define VEC_TYPE(type_name, base_type) +#endif + +VEC_TYPE(ivec2, int) +VEC_TYPE(ivec3, int) +VEC_TYPE(ivec4, int) +VEC_TYPE(vec2, float) +VEC_TYPE(vec3, float) +VEC_TYPE(vec4, float) +VEC_TYPE(lvec2, long) +VEC_TYPE(lvec3, long) +VEC_TYPE(lvec4, long) +VEC_TYPE(dvec2, double) +VEC_TYPE(dvec3, double) +VEC_TYPE(dvec4, double) +VEC_TYPE(uivec2, uint) +VEC_TYPE(uivec3, uint) +VEC_TYPE(uivec4, uint) +VEC_TYPE(ulvec2, ulong) +VEC_TYPE(ulvec3, ulong) +VEC_TYPE(ulvec4, ulong) + +#undef VEC_TYPE diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c index 44c3d74c6..cf2a70c10 100644 --- a/tools/qfcc/source/def.c +++ b/tools/qfcc/source/def.c @@ -584,7 +584,7 @@ initialize_def (symbol_t *sym, expr_t *init, defspace_t *space, if (init->type == ex_error) return; if ((is_array (sym->type) || is_struct (sym->type) - || is_vector(sym->type) || is_quaternion(sym->type)) + || is_nonscalar (sym->type)) && ((init->type == ex_compound) || init->type == ex_nil)) { init_elements (sym->s.def, init); diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 341f6d7a9..21951799c 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -2549,6 +2549,7 @@ array_expr (expr_t *array, expr_t *index) { type_t *array_type = get_type (array); type_t *index_type = get_type (index); + type_t *ele_type; expr_t *scale; expr_t *offset; expr_t *base; @@ -2561,7 +2562,8 @@ array_expr (expr_t *array, expr_t *index) if (index->type == ex_error) return index; - if (!is_ptr (array_type) && !is_array (array_type)) + if (!is_ptr (array_type) && !is_array (array_type) + && !is_nonscalar (array_type)) return error (array, "not an array"); if (!is_integral (index_type)) return error (index, "invalid array index type"); @@ -2573,11 +2575,26 @@ array_expr (expr_t *array, expr_t *index) && array_type->t.array.size && is_constant (index) && (ind < array_type->t.array.base - || ind - array_type->t.array.base >= array_type->t.array.size)) - return error (index, "array index out of bounds"); - scale = new_int_expr (type_size (array_type->t.array.type)); + || ind - array_type->t.array.base >= array_type->t.array.size)) { + return error (index, "array index out of bounds"); + } + if (is_nonscalar (array_type) + && is_constant (index) + && (ind < 0 || ind >= array_type->width)) { + return error (index, "array index out of bounds"); + } + if (is_array (array_type)) { + ele_type = array_type->t.array.type; + base = new_int_expr (array_type->t.array.base); + } else if (is_ptr (array_type)) { + ele_type = array_type->t.fldptr.type; + base = new_int_expr (0); + } else { + ele_type = ev_types[array_type->type]; + base = new_int_expr (0); + } + scale = new_int_expr (type_size (ele_type)); index = binary_expr ('*', index, scale); - base = new_int_expr (array_type->t.array.base); offset = binary_expr ('*', base, scale); index = binary_expr ('-', index, offset); if (is_short_val (index)) @@ -2585,18 +2602,20 @@ array_expr (expr_t *array, expr_t *index) if (is_int_val (index)) ind = expr_int (index); if (is_array (array_type)) { - type_t *element_type = array_type->t.array.type; if (array->type == ex_uexpr && array->e.expr.op == '.') { ptr = array->e.expr.e1; } else { - expr_t *alias = new_offset_alias_expr (element_type, array, 0); - ptr = new_address_expr (element_type, alias, 0); + expr_t *alias = new_offset_alias_expr (ele_type, array, 0); + ptr = new_address_expr (ele_type, alias, 0); } + } else if (is_nonscalar (array_type)) { + expr_t *alias = new_offset_alias_expr (ele_type, array, 0); + ptr = new_address_expr (ele_type, alias, 0); } else { ptr = array; } ptr = offset_pointer_expr (ptr, index); - ptr = cast_expr (pointer_type (array_type->t.array.type), ptr); + ptr = cast_expr (pointer_type (ele_type), ptr); e = unary_expr ('.', ptr); return e; diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index 5bd004d42..162a15147 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -1005,6 +1005,16 @@ binary_expr (int op, expr_t *e1, expr_t *e2) return invalid_binary_expr(op, e1, e2); if (et2 >= ev_type_count || !binary_expr_types[et1][et2]) return invalid_binary_expr(op, e1, e2); + + if ((t1->width > 1 || t2->width > 1)) { + if (t1 != t2) { + return invalid_binary_expr (op, e1, e2); + } + e = new_binary_expr (op, e1, e2); + e->e.expr.type = t1; + return e; + } + expr_type = binary_expr_types[et1][et2]; while (expr_type->op && expr_type->op != op) expr_type++; diff --git a/tools/qfcc/source/expr_compound.c b/tools/qfcc/source/expr_compound.c index e75bb5b70..e8b81747d 100644 --- a/tools/qfcc/source/expr_compound.c +++ b/tools/qfcc/source/expr_compound.c @@ -82,6 +82,31 @@ new_compound_init (void) return c; } +static element_t * +build_array_element_chain(element_chain_t *element_chain, + int array_size, type_t *array_type, + element_t *ele, + int base_offset) +{ + for (int i = 0; i < array_size; i++) { + int offset = base_offset + i * type_size (array_type); + if (ele && ele->expr && ele->expr->type == ex_compound) { + build_element_chain (element_chain, array_type, + ele->expr, offset); + } else { + element_t *element = new_element (0, 0); + element->type = array_type; + element->offset = offset; + element->expr = ele ? ele->expr : 0; // null -> nil + append_init_element (element_chain, element); + } + if (ele) { + ele = ele->next; + } + } + return ele; +} + void build_element_chain (element_chain_t *element_chain, const type_t *type, expr_t *eles, int base_offset) @@ -93,25 +118,9 @@ build_element_chain (element_chain_t *element_chain, const type_t *type, if (is_array (type)) { type_t *array_type = type->t.array.type; int array_size = type->t.array.size; - int i; - - for (i = 0; i < array_size; i++) { - int offset = base_offset + i * type_size (array_type); - if (ele && ele->expr && ele->expr->type == ex_compound) { - build_element_chain (element_chain, array_type, - ele->expr, offset); - } else { - element_t *element = new_element (0, 0); - element->type = array_type; - element->offset = offset; - element->expr = ele ? ele->expr : 0; // null -> nil - append_init_element (element_chain, element); - } - if (ele) { - ele = ele->next; - } - } - } else if (is_struct (type) || is_vector (type) || is_quaternion (type)) { + ele = build_array_element_chain (element_chain, array_size, array_type, + ele, base_offset); + } else if (is_struct (type) || (is_nonscalar (type) && type->t.symtab)) { symtab_t *symtab = type->t.symtab; symbol_t *field; @@ -135,6 +144,12 @@ build_element_chain (element_chain_t *element_chain, const type_t *type, ele = ele->next; } } + } else if (is_nonscalar (type)) { + // vector type with unnamed components + int vec_width = type_width (type); + type_t *vec_type = ev_types[type->type]; + ele = build_array_element_chain (element_chain, vec_width, vec_type, + ele, base_offset); } else { error (eles, "invalid initializer"); } diff --git a/tools/qfcc/source/qc-lex.l b/tools/qfcc/source/qc-lex.l index 3c8e28ec9..e0467f1ef 100644 --- a/tools/qfcc/source/qc-lex.l +++ b/tools/qfcc/source/qc-lex.l @@ -311,6 +311,13 @@ typedef struct { type_t *type; } keyword_t; +// These keywords are part of the Ruamoko language and require the QuakeForge +// Ruamoko VM. +static keyword_t rua_keywords[] = { +#define VEC_TYPE(type_name, base_type) { #type_name, TYPE, &type_##type_name }, +#include "tools/qfcc/include/vec_types.h" +}; + // These keywords are all part of the Ruamoko (Objective-QC) language. // The first time any one of them is encountered, the class system will be // initialized. @@ -450,6 +457,7 @@ keyword_or_id (char *token) static hashtab_t *qf_keyword_tab; static hashtab_t *at_keyword_tab; static hashtab_t *obj_keyword_tab; + static hashtab_t *rua_keyword_tab; keyword_t *keyword = 0; symbol_t *sym; @@ -461,6 +469,7 @@ keyword_or_id (char *token) qf_keyword_tab = Hash_NewTable (253, keyword_get_key, 0, 0, 0); at_keyword_tab = Hash_NewTable (253, keyword_get_key, 0, 0, 0); obj_keyword_tab = Hash_NewTable (253, keyword_get_key, 0, 0, 0); + rua_keyword_tab = Hash_NewTable (253, keyword_get_key, 0, 0, 0); #define NUMKEYS(_k) (sizeof (_k) / sizeof (_k[0])) @@ -472,12 +481,19 @@ keyword_or_id (char *token) Hash_Add (at_keyword_tab, &at_keywords[i]); for (i = 0; i < NUMKEYS(obj_keywords); i++) Hash_Add (obj_keyword_tab, &obj_keywords[i]); + for (i = 0; i < NUMKEYS(rua_keywords); i++) + Hash_Add (rua_keyword_tab, &rua_keywords[i]); } if (options.traditional < 1) { - keyword = Hash_Find (obj_keyword_tab, token); - if (keyword) { - if (!obj_initialized) - class_init (); + if (options.code.progsversion == PROG_VERSION) { + keyword = Hash_Find (rua_keyword_tab, token); + } + if (!keyword) { + keyword = Hash_Find (obj_keyword_tab, token); + if (keyword) { + if (!obj_initialized) + class_init (); + } } if (!keyword) keyword = Hash_Find (qf_keyword_tab, token); diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index 9f94affae..b0882519c 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -79,18 +79,15 @@ type_t type_invalid = { .name = "invalid", }; -#define VTYPE(t, b) \ - type_t type_##t = { \ - .type = ev_##b, \ - .name = #t, \ - .alignment = PR_ALIGNOF(t), \ - .width = PR_SIZEOF(t) / PR_SIZEOF (b), \ +#define VEC_TYPE(type_name, base_type) \ + type_t type_##type_name = { \ + .type = ev_##base_type, \ + .name = #type_name, \ + .alignment = PR_ALIGNOF(type_name), \ + .width = PR_SIZEOF(type_name) / PR_SIZEOF (base_type), \ .meta = ty_basic, \ }; -VTYPE(ivec3, int) -VTYPE(ivec4, int) -VTYPE(vec3, float) -VTYPE(vec4, float) +#include "tools/qfcc/include/vec_types.h" type_t *type_nil; type_t *type_default; @@ -947,6 +944,13 @@ is_integral (const type_t *type) return is_enum (type); } +int +is_real (const type_t *type) +{ + type = unalias_type (type); + return is_float (type) || is_double (type); +} + int is_scalar (const type_t *type) { @@ -958,7 +962,7 @@ is_scalar (const type_t *type) if (type->width != 1) { return 0; } - return is_float (type) || is_integral (type) || is_double (type); + return is_real (type) || is_integral (type); } int @@ -968,7 +972,7 @@ is_nonscalar (const type_t *type) if (type->width < 2) { return 0; } - return is_float (type) || is_integral (type) || is_double (type); + return is_real (type) || is_integral (type); } int @@ -1144,20 +1148,21 @@ type_width (const type_t *type) static void chain_basic_types (void) { + type_entity.t.symtab = pr.entity_fields; + if (options.code.progsversion == PROG_VERSION) { + type_quaternion.alignment = 4; + } + chain_type (&type_void); chain_type (&type_string); chain_type (&type_float); chain_type (&type_vector); - type_entity.t.symtab = pr.entity_fields; chain_type (&type_entity); chain_type (&type_field); chain_type (&type_func); chain_type (&type_ptr); chain_type (&type_floatfield); if (!options.traditional) { - if (options.code.progsversion == PROG_VERSION) { - type_quaternion.alignment = 4; - } chain_type (&type_quaternion); chain_type (&type_int); chain_type (&type_uint); @@ -1165,10 +1170,11 @@ chain_basic_types (void) chain_type (&type_double); if (options.code.progsversion == PROG_VERSION) { - chain_type (&type_ivec3); - chain_type (&type_ivec4); - chain_type (&type_vec3); - chain_type (&type_vec4); + chain_type (&type_long); + chain_type (&type_ulong); + chain_type (&type_ushort); +#define VEC_TYPE(name, type) chain_type (&type_##name); +#include "tools/qfcc/include/vec_types.h" } } } From 52a399daeb8e80f76882aee0e13d469ac35be837 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 08:46:58 +0900 Subject: [PATCH 312/360] [qfcc] Update sizes and alignments for dvec4 and friends dvec4, lvec4 and ulvec4 need to be aligned to 8 words (32 bytes) in order to avoid hardware exceptions. Rather than dealing with possibly mixed alignment when a function has 8-word aligned locals but only 4-word aligned parameters, simply keep the stack frame 8-word aligned at all times. As for sizes, the temp def recycler was written before the Ruamoko ISA was even a pipe dream and thus never expected temp def sizes over 4. At least now any future adjustments can be done in one place. My quick and dirty test program works :) dvec4 xy = {1d, 2d, 0d, 0.5}; void printf(string fmt, ...) = #0; int main() { dvec4 u = {3, 4, 3.14}; dvec4 v = {3, 4, 0, 1}; dvec4 w = v * xy + u; printf ("[%g, %g, %g, %g]\n", w[0], w[1], w[2], w[3]); return 0; } --- tools/qfcc/include/function.h | 4 +++- tools/qfcc/source/def.c | 2 +- tools/qfcc/source/function.c | 16 ++++++++++------ 3 files changed, 14 insertions(+), 8 deletions(-) diff --git a/tools/qfcc/include/function.h b/tools/qfcc/include/function.h index 3a089a4c2..83b455555 100644 --- a/tools/qfcc/include/function.h +++ b/tools/qfcc/include/function.h @@ -41,6 +41,8 @@ #include "def.h" +#define MAX_DEF_SIZE ((int)PR_SIZEOF(lvec4)) + /** Represent an overloading of a function. Every function, whether overloaded or not, has an entry in the overloaded @@ -71,7 +73,7 @@ typedef struct function_s { const struct type_s *type; ///< function's type without aliases int temp_reg; ///< base register to use for temp defs int temp_num; ///< number for next temp var - struct def_s *temp_defs[4]; ///< freed temp vars (by size) + struct def_s *temp_defs[MAX_DEF_SIZE];///< freed temp vars (by size) struct def_s *def; ///< output def holding function number struct symbol_s *sym; ///< internal symbol for this function /** \name Local data space diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c index cf2a70c10..849723a44 100644 --- a/tools/qfcc/source/def.c +++ b/tools/qfcc/source/def.c @@ -209,7 +209,7 @@ temp_def (type_t *type) int size = type_size (type); int alignment = type->alignment; - if (size < 1 || size > 4) { + if (size < 1 || size > MAX_DEF_SIZE) { internal_error (0, "%d invalid size for temp def", size); } if (alignment < 1) { diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index c85b68edf..42f757b9e 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -74,6 +74,9 @@ static hashtab_t *function_map; // standardized base register to use for all locals (arguments, local defs, // params) #define LOCALS_REG 1 +// keep the stack aligned to 8 words (32 bytes) so lvec etc can be used without +// having to do shenanigans with mixed-alignment stack frames +#define STACK_ALIGN 8 static const char * ol_func_get_key (const void *_f, void *unused) @@ -785,26 +788,27 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements) if (func->arguments) { func->arguments->size = func->arguments->max_size; - merge_spaces (space, func->arguments, 4); + merge_spaces (space, func->arguments, STACK_ALIGN); func->arguments = 0; } - merge_spaces (space, func->locals->space, 4); + merge_spaces (space, func->locals->space, STACK_ALIGN); func->locals->space = space; // allocate 0 words to force alignment and get the address - func->params_start = defspace_alloc_aligned_highwater (space, 0, 4); + func->params_start = defspace_alloc_aligned_highwater (space, 0, + STACK_ALIGN); dstatement_t *st = &pr.code->code[func->code]; if (st->op == OP_ADJSTK) { st->b = -func->params_start; } - merge_spaces (space, func->parameters->space, 4); + merge_spaces (space, func->parameters->space, STACK_ALIGN); func->parameters->space = space; // force the alignment again so the full stack slot is counted when - // the final parameter is smaller than 4 words - defspace_alloc_aligned_highwater (space, 0, 4); + // the final parameter is smaller than STACK_ALIGN words + defspace_alloc_aligned_highwater (space, 0, STACK_ALIGN); } return fsym->s.func; } From f3770cc64757f60bdcda39487cc48df608b27bd4 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 09:27:07 +0900 Subject: [PATCH 313/360] [qfcc] Add --ruamoko command line option and pragma The command line option works the same way as --advanced/traditional/extended, as does the pragma. As well, raumoko (alternative spelling) can be used because both are legitimate and some people may prefer one spelling over the other. As always, use of the pragma is at one's own risk: its intended use is forcing the target in the unit tests. --- tools/qfcc/include/options.h | 2 +- tools/qfcc/source/options.c | 34 +++++++++++++++++++++++----------- tools/qfcc/source/pragma.c | 18 +++++++++++++++--- 3 files changed, 39 insertions(+), 15 deletions(-) diff --git a/tools/qfcc/include/options.h b/tools/qfcc/include/options.h index 580f97370..0c274bf7c 100644 --- a/tools/qfcc/include/options.h +++ b/tools/qfcc/include/options.h @@ -109,7 +109,7 @@ typedef struct { qboolean progdefs_h; // generate progdefs.h qboolean qccx_escapes; // use qccx escapes instead of standard C int traditional; // behave more like qcc - qboolean advanced; // behold the power of Ruamoko + int advanced; // behold the power of Ruamoko qboolean compile; // serparate compilation mode qboolean partial_link; // partial linking qboolean preprocess_only;// run only cpp, don't compile diff --git a/tools/qfcc/source/options.c b/tools/qfcc/source/options.c index 573730986..e5ccf0805 100644 --- a/tools/qfcc/source/options.c +++ b/tools/qfcc/source/options.c @@ -69,6 +69,7 @@ enum { OPT_NO_DEFAULT_PATHS, OPT_PROGDEFS, OPT_QCCX_ESCAPES, + OPT_RUAMOKO, OPT_TRADITIONAL, OPT_BUG, }; @@ -92,7 +93,9 @@ static struct option const long_options[] = { {"progs-src", required_argument, 0, 'P'}, {"qccx-escapes", no_argument, 0, OPT_QCCX_ESCAPES}, {"quiet", no_argument, 0, 'q'}, + {"raumoko", no_argument, 0, OPT_RUAMOKO}, {"relocatable", no_argument, 0, 'r'}, + {"ruamoko", no_argument, 0, OPT_RUAMOKO}, {"save-temps", no_argument, 0, 'S'}, {"source", required_argument, 0, 's'}, {"traditional", no_argument, 0, OPT_TRADITIONAL}, @@ -394,16 +397,22 @@ DecodeArgs (int argc, char **argv) break; case OPT_TRADITIONAL: options.traditional = 2; - options.advanced = false; + options.advanced = 0; options.code.progsversion = PROG_ID_VERSION; options.code.const_initializers = true; break; case OPT_ADVANCED: options.traditional = 0; - options.advanced = true; + options.advanced = 1; options.code.progsversion = PROG_V6P_VERSION; options.code.const_initializers = false; break; + case OPT_RUAMOKO: + options.traditional = 0; + options.advanced = 2; + options.code.progsversion = PROG_VERSION; + options.code.const_initializers = false; + break; case OPT_BLOCK_DOT: if (optarg) { char *opts = strdup (optarg); @@ -693,7 +702,7 @@ DecodeArgs (int argc, char **argv) if (saw_MD) options.preprocess_only = 0; if (!source_files && !options.advanced) { - // progs.src mode without --advanced implies --traditional + // progs.src mode without --advanced or --ruamoko implies --traditional // but --extended overrides if (!options.traditional) options.traditional = 2; @@ -712,14 +721,10 @@ DecodeArgs (int argc, char **argv) if (!options.code.progsversion) options.code.progsversion = PROG_V6P_VERSION; if (!options.traditional) { - options.advanced = true; - if (options.code.progsversion < PROG_VERSION) { - add_cpp_def ("-D__RUAMOKO__=1"); - add_cpp_def ("-D__RAUMOKO__=1"); - } else { - add_cpp_def ("-D__RUAMOKO__=2"); - add_cpp_def ("-D__RAUMOKO__=2"); - } + // avanced=2 requires the Ruamoko ISA + options.advanced = 2 - (options.code.progsversion < PROG_VERSION); + const char *ruamoko = va (0, "-D__RUAMOKO__=%d", options.advanced); + add_cpp_def (save_string (ruamoko)); if (options.code.ifstring == (qboolean) -1) options.code.ifstring = false; if (options.code.short_circuit == (qboolean) -1) @@ -741,6 +746,13 @@ DecodeArgs (int argc, char **argv) options.code.crc = false; } + if (options.traditional && options.advanced) { + fprintf (stderr, + "%s: internal error: traditional and advanced twisted\n", + this_program); + abort (); + } + // add the default paths if (!options.no_default_paths) { add_cpp_sysinc ("-isystem"); diff --git a/tools/qfcc/source/pragma.c b/tools/qfcc/source/pragma.c index fb72130f4..9d107edab 100644 --- a/tools/qfcc/source/pragma.c +++ b/tools/qfcc/source/pragma.c @@ -63,21 +63,31 @@ static void set_traditional (int traditional) { switch (traditional) { + case -1: + options.traditional = 0; + options.advanced = 2; + options.code.progsversion = PROG_VERSION; + type_default = &type_int; + type_long_int = &type_long; + type_ulong_uint = &type_ulong; + break; case 0: options.traditional = 0; - options.advanced = true; + options.advanced = 1; options.code.progsversion = PROG_V6P_VERSION; type_default = &type_int; + type_long_int = &type_int; + type_ulong_uint = &type_uint; break; case 1: options.traditional = 1; - options.advanced = false; + options.advanced = 0; options.code.progsversion = PROG_ID_VERSION; type_default = &type_float; break; case 2: options.traditional = 2; - options.advanced = false; + options.advanced = 0; options.code.progsversion = PROG_ID_VERSION; type_default = &type_float; break; @@ -157,6 +167,8 @@ pragma_process () set_traditional (1); } else if (!strcmp (id, "advanced")) { set_traditional (0); + } else if (!strcmp (id, "ruamoko") || !strcmp (id, "raumoko")) { + set_traditional (-1); } else if (!strcmp (id, "bug")) { set_bug (pragma_args->next); } else if (!strcmp (id, "warn")) { From 26fca581fca7bf4ec2e7a3d4baa94f61e2d4f0fa Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 10:46:31 +0900 Subject: [PATCH 314/360] [qfcc] Make ruamoko the default and update the docs It's time to do the dog-food. --- tools/qfcc/doc/man/qfcc.1 | 69 ++++++++++++++++++++++++++----------- tools/qfcc/source/options.c | 7 ++-- 2 files changed, 54 insertions(+), 22 deletions(-) diff --git a/tools/qfcc/doc/man/qfcc.1 b/tools/qfcc/doc/man/qfcc.1 index 893070824..0541458dd 100644 --- a/tools/qfcc/doc/man/qfcc.1 +++ b/tools/qfcc/doc/man/qfcc.1 @@ -56,8 +56,10 @@ understand. .TP .B \-\-advanced -Use advanced Ruamoko features. -This is the default when using separate compilation. +Use advanced Ruamoko language features limited to the v6p ISA. This +provides access to structs, arrays, pointers, integers, quaternions, +doubles and object-oriented features mostly compatible with Objective-C +(ie, Objective-QuakeC). For access to SIMD vector types, see --ruamoko. .TP .B \-C, \-\-code OPTION,... @@ -179,6 +181,15 @@ Counteracts the effects of \fB-v\fP. Incremental linking. Generate a larger object file from other object files and libraries. +.TP +.B \-\-raumoko, \-\-ruamoko +In addition to the Ruamoko language features added by --advanced, this +option provides access to SIMD vector types (and instructions), a data +stack for local variables and parameters (allowing pointers to local +variables to be passed to other functions!), and other features still +under development. +This is the default when using separate compilation. + .TP .B \-S, \-\-save\-temps Do not delete temporary files. @@ -346,16 +357,17 @@ Also disables compiler features (such as integers and string manipulation support) that require extensions. .TP .B v6p -Quakeforge extended v6 instructions. -This is not compatible with older server, nor with most (any?) other Quake -engine. It adds a variety of instructions and types, including integers, +QuakeForge extended v6 instructions. +This is not compatible with older servers, nor with most (any?) other Quake +engines. It adds a variety of instructions and types, including integers, quaternions, pointers, doubles, structs, arrays and Objective-C style classes. .TP .B ruamoko -Quakeforge SIMD instructions. This is currently under development -and thus not the default. +QuakeForge SIMD and stack instructions. .RE -Defaults to v6 for traditional mode and v6p for advanced mode. +Defaults to v6 for traditional mode, v6p for advanced mode, and ruamoko +for Ruamoko mode (actually, trying to take Ruamoko's power after +granting it may not end well). .SH "WARNING OPTIONS" @@ -718,13 +730,13 @@ gold digits. \fB\-\-qccx\-escapes\fP has no effect on sequences that do not conflict. -.SH TRADITIONAL VS ADVANCED -Compared to \fBqcc\fP, \*[qfcc] has many advanced features and is much stricter -about type checking. +.SH TRADITIONAL VS ADVANCED VS RUAMOKO +Compared to \fBqcc\fP, \*[qfcc] has many advanced features and is much +stricter about type checking. \*[qfcc] also uses the same operator semantics and precedence rules as standard \fBC\fP. -Unfortunately, this means that most older QuakeC code will not compile, or even -worse, will compile incorrectly. +Unfortunately, this means that most older QuakeC code will not compile, +or even worse, will compile incorrectly. .P To address this situation, \*[qfcc] has a \*(lqtraditional\*(rq mode for compiling old progs. @@ -732,20 +744,32 @@ This mode, enabled with \fB--traditional\fP or by default in \fBprogs.src\fP mode, removes the new keywords required by \*[qfcc]'s advanced features, converts new errors to warnings, some warnings to notices and inverts precedence order where required (eg, (!var & flag)). -Traditional mode also affects several code generation options (as always, this -can be overridden): +Traditional mode also affects several code generation options (as +always, this can be overridden): .IP \(bu 4 code output is restricted to version 6 progs instructions .IP \(bu 4 short circuit boolean logic is disabled .IP \(bu 4 -each function has a private area of data for its local variables (this wastes -a lot of data space). +each function has a private area of data for its local variables (this +wastes a lot of data space). .P -Advanced mode is simply \*[qfcc] in its natural state. -Using \fB--advanced\fP, \*[qfcc] can be put in to advanced mode while using the -\fBprogs.src\fP compilation mode. +Advanced mode is \*[qfcc] in what was its natural state until the +introduction of Ruamoko mode. Advanced mode adds several data types and +Objective-C object oriented programming. +Using \fB--advanced\fP, \*[qfcc] can be put in to advanced mode while +using the \fBprogs.src\fP compilation mode. +.P +Ruamoko mode is \*[qfcc] in its natural state. On top of the features +added by Advanced mode, Ruamoko mode adds SIMD types and instructions, +and a data stack for locals and parameters. +.SH RUAMOKO PROGRAMMING LANGUAGE +Ruamoko evolved from the original QuakeC language, gaining standard C +syntax and most features (the char type is not supported, and function +pointers are a little weird (design bug?)), Objective-C object oriented +extensions, and (with the Ruamoko ISA) SIMD vectors and the ability to +pass pointers to local variables to other functions. .SH "FAQ" @@ -756,6 +780,11 @@ Sky-father, and Papatuanuku, the Earth-mother. Ruamoko is the god of volcanoes and earthquakes. For more information, see the Web site at <\fBhttp://maori.com/kmst1.htm\fP>. +.TP +.B Why both Ruamoko and Raumoko? +They are alternative spellings and pronunciations. Use whichever one you +prefer. + .TP .B qfcc hangs This is almost always caused by qfcc incorrectly invoking \*[cpp]. diff --git a/tools/qfcc/source/options.c b/tools/qfcc/source/options.c index e5ccf0805..c8a0a7ff0 100644 --- a/tools/qfcc/source/options.c +++ b/tools/qfcc/source/options.c @@ -142,7 +142,6 @@ usage (int status) printf ( "Options:\n" " --advanced Advanced Ruamoko mode\n" -" default for separate compilation mode\n" " --bug OPTION,... Set bug options\n" " -C, --code OPTION,... Set code generation options\n" " -c Only compile, don't link\n" @@ -172,6 +171,10 @@ usage (int status) " C/QuakeForge sequences.\n" " -q, --quiet Inhibit usual output\n" " -r, --relocatable Incremental linking\n" +" --raumoko Use both Ruamoko language features and the\n" +" --ruamoko Ruamoko ISA, providing access to SIMD types\n" +" and a stack for locals.\n" +" default for separate compilation mode\n" " -S, --save-temps Do not delete temporary files\n" " -s, --source DIR Look for progs.src in DIR instead of \".\"\n" " --traditional Traditional QuakeC mode: implies v6only\n" @@ -719,7 +722,7 @@ DecodeArgs (int argc, char **argv) options.code.vector_components = true; } if (!options.code.progsversion) - options.code.progsversion = PROG_V6P_VERSION; + options.code.progsversion = PROG_VERSION; if (!options.traditional) { // avanced=2 requires the Ruamoko ISA options.advanced = 2 - (options.code.progsversion < PROG_VERSION); From b425f449b62c708e053e6d4ec812ac02440b4c46 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 11:38:36 +0900 Subject: [PATCH 315/360] [ruamoko] Separate the two str_mid builtins pr_argc cannot be used in Ruamoko progs because nothing sets it. This fixes the parse errors and resulting segfault when trying to parse the Vulkan pipeline config. --- libs/ruamoko/rua_string.c | 34 ++++++++++++++++++++++++---------- 1 file changed, 24 insertions(+), 10 deletions(-) diff --git a/libs/ruamoko/rua_string.c b/libs/ruamoko/rua_string.c index 4fdbab706..314c6d099 100644 --- a/libs/ruamoko/rua_string.c +++ b/libs/ruamoko/rua_string.c @@ -175,17 +175,10 @@ bi_str_clear (progs_t *pr) } static void -bi_str_mid (progs_t *pr) +str_mid (progs_t *pr, const char *str, int pos, int end, int size) { - const char *str = P_GSTRING (pr, 0); - int pos = P_INT (pr, 1); - int end = P_INT (pr, 2); - int size = strlen (str); char *temp; - if (pr->pr_argc == 2) - end = size; - R_STRING (pr) = 0; if (pos < 0) pos += size; @@ -205,6 +198,27 @@ bi_str_mid (progs_t *pr) RETURN_STRING (pr, temp); } +static void +bi_str_mid_2 (progs_t *pr) +{ + const char *str = P_GSTRING (pr, 0); + int pos = P_INT (pr, 1); + int size = strlen (str); + + str_mid (pr, str, pos, size, size); +} + +static void +bi_str_mid_3 (progs_t *pr) +{ + const char *str = P_GSTRING (pr, 0); + int pos = P_INT (pr, 1); + int end = P_INT (pr, 2); + int size = strlen (str); + + str_mid (pr, str, pos, end, size); +} + static void bi_str_str (progs_t *pr) { @@ -316,8 +330,8 @@ static builtin_t builtins[] = { bi(str_copy, 2, p(string), p(string)), bi(str_cat, 2, p(string), p(string)), bi(str_clear, 1, p(string)), - {"str_mid|*i", bi_str_mid, -1, 2, {p(string), p(int)}}, - {"str_mid|*ii", bi_str_mid, -1, 3, {p(string), p(int), p(int)}}, + {"str_mid|*i", bi_str_mid_2, -1, 2, {p(string), p(int)}}, + {"str_mid|*ii", bi_str_mid_3, -1, 3, {p(string), p(int), p(int)}}, bi(str_str, 2, p(string), p(string)), bi(str_char, 2, p(string), p(int)), bi(str_quote, 1, p(string)), From 974af36d138e2b494a980defcfddcc6ec7da349b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 21:46:40 +0900 Subject: [PATCH 316/360] [gamecode] Move profile out of the union It happens to sit over the builtin data pointer and thus messes up PR_Profile (any attempt to count calls to builtins). --- include/QF/progs.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 5a00afd46..f5ffb1a94 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1255,13 +1255,13 @@ typedef struct { typedef struct { pr_int_t first_statement; pr_int_t numparams; + pr_ulong_t profile; union { struct { dparmsize_t param_size[PR_MAX_PARAMS]; dfunction_t *descriptor; pr_uint_t params_start; pr_uint_t locals; - pr_uint_t profile; }; struct { // although Ruamoko progs support more than PR_MAX_PARAMS From 7731c469e23217419301262a5c94fef8ec67ffb6 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 21:49:59 +0900 Subject: [PATCH 317/360] [gamecode] Count calls to builtins in profile It's a bit disconcerting seeing a builtin in the top 10 when builtins are counted by call while progs functions are counted by instruction. Also, show the total profile after the function top-10 list. --- libs/gamecode/pr_debug.c | 14 +++++++++++--- libs/gamecode/pr_exec.c | 1 + 2 files changed, 12 insertions(+), 3 deletions(-) diff --git a/libs/gamecode/pr_debug.c b/libs/gamecode/pr_debug.c index 041963233..67f6b981e 100644 --- a/libs/gamecode/pr_debug.c +++ b/libs/gamecode/pr_debug.c @@ -1787,11 +1787,17 @@ PR_StackTrace (progs_t *pr) VISIBLE void PR_Profile (progs_t * pr) { - pr_uint_t max, num, i; + pr_ulong_t max, num, i; + pr_ulong_t total; dfunction_t *f; bfunction_t *best, *bf; num = 0; + total = 0; + for (i = 0; i < pr->progs->functions.count; i++) { + bf = &pr->function_table[i]; + total += bf->profile; + } do { max = 0; best = NULL; @@ -1805,13 +1811,15 @@ PR_Profile (progs_t * pr) if (best) { if (num < 10) { f = pr->pr_functions + (best - pr->function_table); - Sys_Printf ("%7i %s\n", best->profile, - PR_GetString (pr, f->name)); + Sys_Printf ("%7"PRIu64" %s%s\n", best->profile, + PR_GetString (pr, f->name), + f->first_statement < 0 ? " (builtin)" : ""); } num++; best->profile = 0; } } while (best); + Sys_Printf ("total: %7"PRIu64"\n", total); } static void diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index febb93266..4bbf3ca81 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -455,6 +455,7 @@ PR_CallFunction (progs_t *pr, pr_func_t fnum, pr_type_t *return_ptr) int builtin_depth = pr->pr_depth; pr->pr_return = return_ptr; f->func (pr); + f->profile++; // to show number times the builtin is called if (builtin_depth == pr->pr_depth) { pr->pr_return = saved_return; } else if (builtin_depth < pr->pr_depth) { From 2a8fca80a09f2b126e1ba0dbb35c4214522feb0d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 21:53:37 +0900 Subject: [PATCH 318/360] [nq,qw] Give the menu and server progs stacks They're going to need them :P --- libs/console/menu.c | 1 + nq/source/sv_progs.c | 4 ++++ qw/source/sv_progs.c | 4 ++++ 3 files changed, 9 insertions(+) diff --git a/libs/console/menu.c b/libs/console/menu.c index fd34f6a68..b8e9ccaf7 100644 --- a/libs/console/menu.c +++ b/libs/console/menu.c @@ -594,6 +594,7 @@ Menu_Init (void) menu_pr_state.max_edicts = 0; menu_pr_state.zone_size = 1024 * 1024; + menu_pr_state.stack_size = 64 * 1024; PR_Init (&menu_pr_state); diff --git a/nq/source/sv_progs.c b/nq/source/sv_progs.c index a6cc1cbc7..a0235e108 100644 --- a/nq/source/sv_progs.c +++ b/nq/source/sv_progs.c @@ -57,6 +57,7 @@ sv_data_t sv_data[MAX_EDICTS]; cvar_t *sv_progs; cvar_t *sv_progs_zone; +cvar_t *sv_progs_stack; cvar_t *sv_progs_ext; cvar_t *pr_checkextensions; @@ -514,6 +515,7 @@ SV_LoadProgs (void) sv_pr_state.max_edicts = sv.max_edicts; sv_pr_state.zone_size = sv_progs_zone->int_val * 1024; + sv_pr_state.stack_size = sv_progs_stack->int_val * 1024; sv.edicts = sv_edicts; PR_LoadProgs (&sv_pr_state, progs_name); @@ -561,6 +563,8 @@ SV_Progs_Init_Cvars (void) "Override the default game progs."); sv_progs_zone = Cvar_Get ("sv_progs_zone", "256", CVAR_NONE, NULL, "size of the zone for progs in kb"); + sv_progs_stack = Cvar_Get ("sv_progs_stack", "256", CVAR_NONE, NULL, + "size of the stack for progs in kb"); sv_progs_ext = Cvar_Get ("sv_progs_ext", "qf", CVAR_NONE, NULL, "extention mapping to use: " "none, id, qf"); diff --git a/qw/source/sv_progs.c b/qw/source/sv_progs.c index 8c8809c38..77d7898ff 100644 --- a/qw/source/sv_progs.c +++ b/qw/source/sv_progs.c @@ -60,6 +60,7 @@ sv_data_t sv_data[MAX_EDICTS]; cvar_t *r_skyname; cvar_t *sv_progs; cvar_t *sv_progs_zone; +cvar_t *sv_progs_stack; cvar_t *sv_progs_ext; cvar_t *pr_checkextensions; cvar_t *sv_old_entity_free; @@ -560,6 +561,7 @@ SV_LoadProgs (void) sv_pr_state.max_edicts = MAX_EDICTS; sv_pr_state.zone_size = sv_progs_zone->int_val * 1024; + sv_pr_state.stack_size = sv_progs_stack->int_val * 1024; sv.edicts = sv_edicts; PR_LoadProgs (&sv_pr_state, progs_name); @@ -614,6 +616,8 @@ SV_Progs_Init_Cvars (void) "Override the default game progs."); sv_progs_zone = Cvar_Get ("sv_progs_zone", "256", CVAR_NONE, NULL, "size of the zone for progs in kB"); + sv_progs_stack = Cvar_Get ("sv_progs_stack", "64", CVAR_NONE, NULL, + "size of the stack for progs in kB"); sv_progs_ext = Cvar_Get ("sv_progs_ext", "qf", CVAR_NONE, NULL, "extention mapping to use: " "none, id, qf, qwe, ktpro, cpqw"); From 1b40cdbab6ee5aae420094ece56d81ff381e1c55 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 21:57:41 +0900 Subject: [PATCH 319/360] [qfcc] Handle vector scaling by ints I missed a change when implementing support for the scale instructions. --- tools/qfcc/source/dot_expr.c | 2 ++ tools/qfcc/source/expr_binary.c | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/dot_expr.c b/tools/qfcc/source/dot_expr.c index 04784856a..52db56ca9 100644 --- a/tools/qfcc/source/dot_expr.c +++ b/tools/qfcc/source/dot_expr.c @@ -75,6 +75,7 @@ get_op_string (int op) case GE: return ">="; case LT: return "<"; case GT: return ">"; + case '=': return "="; case '+': return "+"; case '-': return "-"; case '*': return "*"; @@ -92,6 +93,7 @@ get_op_string (int op) case 'C': return ""; case CROSS: return "@cross"; case DOT: return "@dot"; + case SCALE: return "@scale"; default: return "unknown"; } diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index 162a15147..8c2881a64 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -258,7 +258,7 @@ static expr_type_t int_float[] = { }; static expr_type_t int_vector[] = { - {'*', &type_vector, &type_float, 0}, + {'*', &type_vector, &type_float, 0, vector_scale}, {0, 0} }; From 24a42dc064335d9c96b7e0c8b0df1afa2d6df5fe Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 22:00:18 +0900 Subject: [PATCH 320/360] [qfcc] Emit args for ... functions with no other parameters I missed that the block was < -1, ie at least one real parameters. --- tools/qfcc/source/expr.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 21951799c..1efde4579 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -2161,7 +2161,6 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) warning (fexpr, "too few arguments"); } param_count = -ftype->t.func.num_params - 1; - emit_args = !ftype->t.func.no_va_list; } else if (ftype->t.func.num_params >= 0) { if (arg_count > ftype->t.func.num_params) { return error (fexpr, "too many arguments"); @@ -2173,6 +2172,9 @@ build_function_call (expr_t *fexpr, const type_t *ftype, expr_t *params) } param_count = ftype->t.func.num_params; } + if (ftype->t.func.num_params < 0) { + emit_args = !ftype->t.func.no_va_list; + } // params is reversed (a, b, c) -> c, b, a for (i = arg_count - 1, e = params; i >= 0; i--, e = e->next) { type_t *t; From 6988752dea3d0b37e810cce3401410b52c7365b4 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 22:02:05 +0900 Subject: [PATCH 321/360] [qfcc] Clean up line numbers in varargs setup It's never nice getting the end-of-function line in the middle of some code. --- tools/qfcc/source/statements.c | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index aaba453ff..6fdefa80b 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1218,6 +1218,7 @@ expr_call (sblock_t *sblock, expr_t *call, operand_t **op) } else { list = new_nil_expr (); } + expr_file_line (list, call); assign = assign_expr (args_list, list); expr_file_line (assign, call); sblock = statement_slist (sblock, assign); From b6a8a93cc319b2252ac86a1d3bcad9b77ddea155 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 22:03:26 +0900 Subject: [PATCH 322/360] [qfcc] Treat vectors and quaternions as non-scalars Fixes a segfault when initializing vectors thai was caused by the earlier block init fix. --- tools/qfcc/source/type.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index b0882519c..c9a3c6d75 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -969,6 +969,9 @@ int is_nonscalar (const type_t *type) { type = unalias_type (type); + if (is_vector (type) || is_quaternion (type)) { + return 1; + } if (type->width < 2) { return 0; } From cdc3c9822d4f37f2767fbe0fc360315ec265e91f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 22:09:38 +0900 Subject: [PATCH 323/360] [ruamoko] Preserve the stack in obj_msg_sendv obj_msg_sendv needs to push the parameters onto the stack for Ruamoko progs, but this causes problems because PR_CallFunction winds up recording the wrong stack pointer for progs functions, and nothing restores the stack for builtins. The handling is basically the same as for the return pointer. --- libs/ruamoko/rua_obj.c | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index 971ba55b8..a4fc74f9e 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -1430,6 +1430,11 @@ rua_obj_msg_sendv (progs_t *pr) // replace them count -= 2; params += 2 * pr->pr_param_size; + pr_ptr_t saved_stack = 0; + int sendv_depth = pr->pr_depth; + if (pr->globals.stack) { + saved_stack = *pr->globals.stack; + } PR_RESET_PARAMS (pr); P_POINTER (pr, 0) = obj; P_POINTER (pr, 1) = sel; @@ -1437,7 +1442,15 @@ rua_obj_msg_sendv (progs_t *pr) memcpy (&P_INT (pr, 2), params, count * sizeof (pr_type_t) * pr->pr_param_size); } - PR_CallFunction (pr, imp, pr->pr_return); + if (PR_CallFunction (pr, imp, pr->pr_return)) { + // the call is to a progs function so a frame was pushed, ensure + // the stack pointer is restored on return + // if there's no stack, then the following is effectively a noop + pr->pr_stack[sendv_depth].stack_ptr = saved_stack; + } else if (pr->globals.stack) { + // the call was to a builtin, restore the stack + *pr->globals.stack = saved_stack; + } } static void From 5f684b2f81e312c3e91b5ad381859dba7a324766 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 22:15:24 +0900 Subject: [PATCH 324/360] [ruamoko] Rework PF_VarString to work with Ruamoko progs It's a rather core function used by the game code, though it is rather horrid. --- libs/ruamoko/pr_cmds.c | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-) diff --git a/libs/ruamoko/pr_cmds.c b/libs/ruamoko/pr_cmds.c index 24d3f6294..93cec016e 100644 --- a/libs/ruamoko/pr_cmds.c +++ b/libs/ruamoko/pr_cmds.c @@ -59,12 +59,27 @@ PF_VarString (progs_t *pr, int first) char *out, *dst; const char *src; int len, i; + int argc = pr->pr_argc; + pr_type_t **argv = pr->pr_params; - for (len = 0, i = first; i < pr->pr_argc; i++) - len += strlen (P_GSTRING (pr, i)); + if (pr->progs->version == PROG_VERSION) { + __auto_type va_list = &P_PACKED (pr, pr_va_list_t, 0); + argc = va_list->count; + if (argc) { + argv = alloca (argc * sizeof (pr_type_t *)); + for (int i = 0; i < argc; i++) { + argv[i] = &pr->pr_globals[va_list->list + i * 4]; + } + } else { + argv = 0; + } + } + + for (len = 0, i = first; i < argc; i++) + len += strlen (PR_GetString (pr, argv[i]->string_var)); dst = out = Hunk_TempAlloc (0, len + 1); - for (i = first; i < pr->pr_argc; i++) { - src = P_GSTRING (pr, i); + for (i = first; i < argc; i++) { + src = PR_GetString (pr, argv[i]->string_var); while (*src) *dst++ = *src++; } From 2fc35b39b0cc35dd339ed56eeaa36a3bcd712d63 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 22:19:05 +0900 Subject: [PATCH 325/360] [ruamoko] Use a shared implementation for set functions I suppose having one builtin call another was a neat idea at the time, and really could have been fixed by simply wrapping the calls with push/pop frame, but this is probably faster. --- libs/ruamoko/rua_set.c | 323 ++++++++++++++++++++++++----------------- 1 file changed, 193 insertions(+), 130 deletions(-) diff --git a/libs/ruamoko/rua_set.c b/libs/ruamoko/rua_set.c index b1b3a7dee..c8a0f2672 100644 --- a/libs/ruamoko/rua_set.c +++ b/libs/ruamoko/rua_set.c @@ -219,111 +219,177 @@ bi_set_delete (progs_t *pr) res_set_free (res, set); } +static void +rua_set_add (progs_t *pr, pr_int_t setid, pr_uint_t element) +{ + bi_set_t *set = get_set (pr, __FUNCTION__, setid); + + set_add (set->set, element); +} + static void bi_set_add (progs_t *pr) { - bi_set_t *set = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - - set_add (set->set, P_UINT (pr, 1)); + rua_set_add (pr, P_INT (pr, 0), P_UINT (pr, 1)); R_INT (pr) = P_INT (pr, 0); } +static void +rua_set_remove (progs_t *pr, pr_int_t setid, pr_uint_t element) +{ + bi_set_t *set = get_set (pr, __FUNCTION__, setid); + + set_remove (set->set, element); +} + static void bi_set_remove (progs_t *pr) { - bi_set_t *set = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - - set_remove (set->set, P_UINT (pr, 1)); + rua_set_remove (pr, P_INT (pr, 0), P_UINT (pr, 1)); R_INT (pr) = P_INT (pr, 0); } +static void +rua_set_invert (progs_t *pr, pr_int_t setid) +{ + bi_set_t *set = get_set (pr, __FUNCTION__, setid); + + set_invert (set->set); +} + static void bi_set_invert (progs_t *pr) { - bi_set_t *set = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - - set_invert (set->set); + rua_set_invert (pr, P_INT (pr, 0)); R_INT (pr) = P_INT (pr, 0); } +static void +rua_set_union (progs_t *pr, pr_int_t dstid, pr_int_t srcid) +{ + bi_set_t *dst = get_set (pr, __FUNCTION__, dstid); + bi_set_t *src = get_set (pr, __FUNCTION__, srcid); + + set_union (dst->set, src->set); +} + static void bi_set_union (progs_t *pr) { - bi_set_t *set1 = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - bi_set_t *set2 = get_set (pr, __FUNCTION__, P_INT (pr, 1)); - - set_union (set1->set, set2->set); + rua_set_union (pr, P_INT (pr, 0), P_INT (pr, 1)); R_INT (pr) = P_INT (pr, 0); } +static void +rua_set_intersection (progs_t *pr, pr_int_t dstid, pr_int_t srcid) +{ + bi_set_t *dst = get_set (pr, __FUNCTION__, dstid); + bi_set_t *src = get_set (pr, __FUNCTION__, srcid); + + set_intersection (dst->set, src->set); +} + static void bi_set_intersection (progs_t *pr) { - bi_set_t *set1 = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - bi_set_t *set2 = get_set (pr, __FUNCTION__, P_INT (pr, 1)); - - set_intersection (set1->set, set2->set); + rua_set_intersection (pr, P_INT (pr, 0), P_INT (pr, 1)); R_INT (pr) = P_INT (pr, 0); } +static void +rua_set_difference (progs_t *pr, pr_int_t dstid, pr_int_t srcid) +{ + bi_set_t *dst = get_set (pr, __FUNCTION__, dstid); + bi_set_t *src = get_set (pr, __FUNCTION__, srcid); + + set_difference (dst->set, src->set); +} + static void bi_set_difference (progs_t *pr) { - bi_set_t *set1 = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - bi_set_t *set2 = get_set (pr, __FUNCTION__, P_INT (pr, 1)); - - set_difference (set1->set, set2->set); + rua_set_difference (pr, P_INT (pr, 0), P_INT (pr, 1)); R_INT (pr) = P_INT (pr, 0); } +static void +rua_set_reverse_difference (progs_t *pr, pr_int_t dstid, pr_int_t srcid) +{ + bi_set_t *dst = get_set (pr, __FUNCTION__, dstid); + bi_set_t *src = get_set (pr, __FUNCTION__, srcid); + + set_reverse_difference (dst->set, src->set); +} + static void bi_set_reverse_difference (progs_t *pr) { - bi_set_t *set1 = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - bi_set_t *set2 = get_set (pr, __FUNCTION__, P_INT (pr, 1)); - - set_reverse_difference (set1->set, set2->set); + rua_set_reverse_difference (pr, P_INT (pr, 0), P_INT (pr, 1)); R_INT (pr) = P_INT (pr, 0); } +static void +rua_set_assign (progs_t *pr, pr_int_t dstid, pr_int_t srcid) +{ + bi_set_t *dst = get_set (pr, __FUNCTION__, dstid); + bi_set_t *src = get_set (pr, __FUNCTION__, srcid); + + set_assign (dst->set, src->set); +} + static void bi_set_assign (progs_t *pr) { - bi_set_t *set1 = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - bi_set_t *set2 = get_set (pr, __FUNCTION__, P_INT (pr, 1)); - - set_assign (set1->set, set2->set); + rua_set_assign (pr, P_INT (pr, 0), P_INT (pr, 1)); R_INT (pr) = P_INT (pr, 0); } +static void +rua_set_empty (progs_t *pr, pr_int_t setid) +{ + bi_set_t *set = get_set (pr, __FUNCTION__, setid); + + set_empty (set->set); +} + static void bi_set_empty (progs_t *pr) { - bi_set_t *set = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - - set_empty (set->set); + rua_set_empty (pr, P_INT (pr, 0)); R_INT (pr) = P_INT (pr, 0); } +static void +rua_set_everything (progs_t *pr, pr_int_t setid) +{ + bi_set_t *set = get_set (pr, __FUNCTION__, setid); + + set_everything (set->set); +} + static void bi_set_everything (progs_t *pr) { - bi_set_t *set = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - - set_everything (set->set); + rua_set_everything (pr, P_INT (pr, 0)); R_INT (pr) = P_INT (pr, 0); } static void -bi_set_is_empty (progs_t *pr) +rua_set_is_empty (progs_t *pr, pr_int_t setid) { - bi_set_t *set = get_set (pr, __FUNCTION__, P_INT (pr, 0)); + bi_set_t *set = get_set (pr, __FUNCTION__, setid); R_INT (pr) = set_is_empty (set->set); } static void -bi_set_is_everything (progs_t *pr) +bi_set_is_empty (progs_t *pr) +{ + rua_set_is_empty (pr, P_INT (pr, 0)); +} + +static void +rua_set_is_everything (progs_t *pr, pr_int_t setid) { bi_set_t *set = get_set (pr, __FUNCTION__, P_INT (pr, 0)); @@ -331,55 +397,97 @@ bi_set_is_everything (progs_t *pr) } static void -bi_set_is_disjoint (progs_t *pr) +bi_set_is_everything (progs_t *pr) { - bi_set_t *set1 = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - bi_set_t *set2 = get_set (pr, __FUNCTION__, P_INT (pr, 1)); + rua_set_is_everything (pr, P_INT (pr, 0)); +} + +static void +rua_set_is_disjoint (progs_t *pr, pr_int_t sid1, pr_int_t sid2) +{ + bi_set_t *set1 = get_set (pr, __FUNCTION__, sid1); + bi_set_t *set2 = get_set (pr, __FUNCTION__, sid2); R_INT (pr) = set_is_disjoint (set1->set, set2->set); } static void -bi_set_is_intersecting (progs_t *pr) +bi_set_is_disjoint (progs_t *pr) { - bi_set_t *set1 = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - bi_set_t *set2 = get_set (pr, __FUNCTION__, P_INT (pr, 1)); + rua_set_is_disjoint (pr, P_INT (pr, 0), P_INT (pr, 1)); +} + +static void +rua_set_is_intersecting (progs_t *pr, pr_int_t sid1, pr_int_t sid2) +{ + bi_set_t *set1 = get_set (pr, __FUNCTION__, sid1); + bi_set_t *set2 = get_set (pr, __FUNCTION__, sid2); R_INT (pr) = set_is_intersecting (set1->set, set2->set); } static void -bi_set_is_equivalent (progs_t *pr) +bi_set_is_intersecting (progs_t *pr) { - bi_set_t *set1 = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - bi_set_t *set2 = get_set (pr, __FUNCTION__, P_INT (pr, 1)); + rua_set_is_intersecting (pr, P_INT (pr, 0), P_INT (pr, 1)); +} + +static void +rua_set_is_equivalent (progs_t *pr, pr_int_t sid1, pr_int_t sid2) +{ + bi_set_t *set1 = get_set (pr, __FUNCTION__, sid1); + bi_set_t *set2 = get_set (pr, __FUNCTION__, sid2); R_INT (pr) = set_is_equivalent (set1->set, set2->set); } +static void +bi_set_is_equivalent (progs_t *pr) +{ + rua_set_is_equivalent (pr, P_INT (pr, 0), P_INT (pr, 1)); +} + +static void +rua_set_is_subset (progs_t *pr, pr_int_t setid, pr_int_t subid) +{ + bi_set_t *set = get_set (pr, __FUNCTION__, setid); + bi_set_t *sub = get_set (pr, __FUNCTION__, subid); + + R_INT (pr) = set_is_subset (set->set, sub->set); +} + static void bi_set_is_subset (progs_t *pr) { - bi_set_t *set1 = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - bi_set_t *set2 = get_set (pr, __FUNCTION__, P_INT (pr, 1)); + rua_set_is_subset (pr, P_INT (pr, 0), P_INT (pr, 1)); +} - R_INT (pr) = set_is_subset (set1->set, set2->set); +static void +rua_set_is_member (progs_t *pr, pr_int_t setid, pr_uint_t element) +{ + bi_set_t *set = get_set (pr, __FUNCTION__, setid); + + R_INT (pr) = set_is_member (set->set, element); } static void bi_set_is_member (progs_t *pr) { - bi_set_t *set = get_set (pr, __FUNCTION__, P_INT (pr, 0)); + rua_set_is_member (pr, P_INT (pr, 0), P_UINT (pr, 1)); +} - R_INT (pr) = set_is_member (set->set, P_UINT (pr, 1)); +static void +rua_set_count (progs_t *pr, pr_int_t setid) +{ + bi_set_t *set = get_set (pr, __FUNCTION__, setid); + + R_INT (pr) = set_count (set->set); } static void bi_set_count (progs_t *pr) { - bi_set_t *set = get_set (pr, __FUNCTION__, P_INT (pr, 0)); - - R_INT (pr) = set_count (set->set); + rua_set_count (pr, P_INT (pr, 0)); } static void @@ -422,13 +530,19 @@ bi_set_next (progs_t *pr) } static void -bi_set_as_string (progs_t *pr) +rua_set_as_string (progs_t *pr, pr_int_t setid) { - bi_set_t *set = get_set (pr, __FUNCTION__, P_INT (pr, 0)); + bi_set_t *set = get_set (pr, __FUNCTION__, setid); RETURN_STRING (pr, set_as_string (set->set)); } +static void +bi_set_as_string (progs_t *pr) +{ + rua_set_as_string (pr, P_INT (pr, 0)); +} + static void bi__i_SetIterator__element (progs_t *pr) { @@ -444,10 +558,7 @@ bi__i_Set__add_ (progs_t *pr) pr_ptr_t set_ptr = P_POINTER (pr, 0); pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = set_obj->set; - P_INT (pr, 1) = P_INT (pr, 2); - bi_set_add (pr); + rua_set_add (pr, set_obj->set, P_UINT (pr, 2)); R_INT (pr) = set_ptr; } @@ -457,10 +568,7 @@ bi__i_Set__remove_ (progs_t *pr) pr_ptr_t set_ptr = P_POINTER (pr, 0); pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = set_obj->set; - P_INT (pr, 1) = P_INT (pr, 2); - bi_set_remove (pr); + rua_set_remove (pr, set_obj->set, P_UINT (pr, 2)); R_INT (pr) = set_ptr; } @@ -470,9 +578,7 @@ bi__i_Set__invert (progs_t *pr) pr_ptr_t set_ptr = P_POINTER (pr, 0); pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = set_obj->set; - bi_set_invert (pr); + rua_set_invert (pr, set_obj->set); R_INT (pr) = set_ptr; } @@ -481,13 +587,9 @@ bi__i_Set__union_ (progs_t *pr) { pr_ptr_t dst_ptr = P_POINTER (pr, 0); pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); - pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); + pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = dst_obj->set; - P_INT (pr, 1) = src_obj->set; - bi_set_union (pr); - R_INT (pr) = dst_ptr; + rua_set_union (pr, dst_obj->set, src_obj->set); } static void @@ -497,10 +599,7 @@ bi__i_Set__intersection_ (progs_t *pr) pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = dst_obj->set; - P_INT (pr, 1) = src_obj->set; - bi_set_intersection (pr); + rua_set_intersection (pr, dst_obj->set, src_obj->set); R_INT (pr) = dst_ptr; } @@ -511,10 +610,7 @@ bi__i_Set__difference_ (progs_t *pr) pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = dst_obj->set; - P_INT (pr, 1) = src_obj->set; - bi_set_difference (pr); + rua_set_difference (pr, dst_obj->set, src_obj->set); R_INT (pr) = dst_ptr; } @@ -525,10 +621,7 @@ bi__i_Set__reverse_difference_ (progs_t *pr) pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = dst_obj->set; - P_INT (pr, 1) = src_obj->set; - bi_set_reverse_difference (pr); + rua_set_reverse_difference (pr, dst_obj->set, src_obj->set); R_INT (pr) = dst_ptr; } @@ -539,10 +632,7 @@ bi__i_Set__assign_ (progs_t *pr) pr_set_t *dst_obj = &G_STRUCT (pr, pr_set_t, dst_ptr); pr_set_t *src_obj = &P_STRUCT (pr, pr_set_t, 2); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = dst_obj->set; - P_INT (pr, 1) = src_obj->set; - bi_set_assign (pr); + rua_set_assign (pr, dst_obj->set, src_obj->set); R_INT (pr) = dst_ptr; } @@ -552,9 +642,7 @@ bi__i_Set__empty (progs_t *pr) pr_ptr_t set_ptr = P_POINTER (pr, 0); pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = set_obj->set; - bi_set_empty (pr); + rua_set_empty (pr, set_obj->set); R_INT (pr) = set_ptr; } @@ -564,9 +652,7 @@ bi__i_Set__everything (progs_t *pr) pr_ptr_t set_ptr = P_POINTER (pr, 0); pr_set_t *set_obj = &G_STRUCT (pr, pr_set_t, set_ptr); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = set_obj->set; - bi_set_everything (pr); + rua_set_everything (pr, set_obj->set); R_INT (pr) = set_ptr; } @@ -575,9 +661,7 @@ bi__i_Set__is_empty (progs_t *pr) { pr_set_t *set_obj = &P_STRUCT (pr, pr_set_t, 0); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = set_obj->set; - bi_set_is_empty (pr); + rua_set_is_empty (pr, set_obj->set); } static void @@ -585,9 +669,7 @@ bi__i_Set__is_everything (progs_t *pr) { pr_set_t *set_obj = &P_STRUCT (pr, pr_set_t, 0); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = set_obj->set; - bi_set_is_everything (pr); + rua_set_is_everything (pr, set_obj->set); } static void @@ -596,10 +678,7 @@ bi__i_Set__is_disjoint_ (progs_t *pr) pr_set_t *s1_obj = &P_STRUCT (pr, pr_set_t, 0); pr_set_t *s2_obj = &P_STRUCT (pr, pr_set_t, 2); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = s1_obj->set; - P_INT (pr, 1) = s2_obj->set; - bi_set_is_disjoint (pr); + rua_set_is_disjoint (pr, s1_obj->set, s2_obj->set); } static void @@ -608,10 +687,7 @@ bi__i_Set__is_intersecting_ (progs_t *pr) pr_set_t *s1_obj = &P_STRUCT (pr, pr_set_t, 0); pr_set_t *s2_obj = &P_STRUCT (pr, pr_set_t, 2); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = s1_obj->set; - P_INT (pr, 1) = s2_obj->set; - bi_set_is_intersecting (pr); + rua_set_is_intersecting (pr, s1_obj->set, s2_obj->set); } static void @@ -620,22 +696,16 @@ bi__i_Set__is_equivalent_ (progs_t *pr) pr_set_t *s1_obj = &P_STRUCT (pr, pr_set_t, 0); pr_set_t *s2_obj = &P_STRUCT (pr, pr_set_t, 2); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = s1_obj->set; - P_INT (pr, 1) = s2_obj->set; - bi_set_is_equivalent (pr); + rua_set_is_equivalent (pr, s1_obj->set, s2_obj->set); } static void bi__i_Set__is_subset_ (progs_t *pr) { - pr_set_t *s1_obj = &P_STRUCT (pr, pr_set_t, 0); - pr_set_t *s2_obj = &P_STRUCT (pr, pr_set_t, 2); + pr_set_t *set_obj = &P_STRUCT (pr, pr_set_t, 0); + pr_set_t *sub_obj = &P_STRUCT (pr, pr_set_t, 2); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = s1_obj->set; - P_INT (pr, 1) = s2_obj->set; - bi_set_is_subset (pr); + rua_set_is_subset (pr, set_obj->set, sub_obj->set); } static void @@ -643,10 +713,7 @@ bi__i_Set__is_member_ (progs_t *pr) { pr_set_t *set_obj = &P_STRUCT (pr, pr_set_t, 0); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = set_obj->set; - P_UINT (pr, 1) = P_UINT (pr, 2); - bi_set_is_member (pr); + rua_set_is_member (pr, set_obj->set, P_UINT (pr, 2)); } static void @@ -654,9 +721,7 @@ bi__i_Set__size (progs_t *pr) { pr_set_t *set_obj = &P_STRUCT (pr, pr_set_t, 0); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = set_obj->set; - bi_set_count (pr); + rua_set_count (pr, set_obj->set); } static void @@ -664,9 +729,7 @@ bi__i_Set__as_string (progs_t *pr) { pr_set_t *set_obj = &P_STRUCT (pr, pr_set_t, 0); - PR_RESET_PARAMS (pr); - P_INT (pr, 0) = set_obj->set; - bi_set_as_string (pr); + rua_set_as_string (pr, set_obj->set); } static void From f94d5e9fdbe6c9e1f1f77e9e246a5ee1f3d5e5c4 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Fri, 4 Feb 2022 22:31:36 +0900 Subject: [PATCH 326/360] [ruamoko] Correct decls for functions using PF_VarString Need to ensure va_list gets into the arguments so PF_VarString can work with Ruamoko progs. --- ruamoko/include/debug.h | 6 +++--- ruamoko/include/message.h | 2 +- ruamoko/lib/debug.r | 6 +++--- ruamoko/lib/message.r | 2 +- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/ruamoko/include/debug.h b/ruamoko/include/debug.h index 017ca1858..9ea089de0 100644 --- a/ruamoko/include/debug.h +++ b/ruamoko/include/debug.h @@ -62,18 +62,18 @@ /** Print a string to the console if the "developer" Cvar is nonzero. */ -@extern void dprint (string str); +@extern void dprint (.../*string str*/); /** Abort (crash) the server. "str" is the message the server crashes with. */ -@extern void error (string str); +@extern void error (.../*string str*/); /** Prints info on the "self" ENTITY (not object), and error message "e". The entity is freed. */ -@extern void objerror (string e); +@extern void objerror (.../*string e*/); //\} #endif //__ruamoko_debug_h diff --git a/ruamoko/include/message.h b/ruamoko/include/message.h index 7d37e91f5..f0cf5c140 100644 --- a/ruamoko/include/message.h +++ b/ruamoko/include/message.h @@ -35,7 +35,7 @@ #define MULTICAST_PVS_R 5 @extern void bprint (...); -@extern void sprint (entity client, string s); +@extern void sprint (.../*entity client, string s*/); @extern void WriteBytes (float to, ...); @extern void WriteByte (float to, float f); @extern void WriteChar (float to, float f); diff --git a/ruamoko/lib/debug.r b/ruamoko/lib/debug.r index 7cf9c8895..0f2f09375 100644 --- a/ruamoko/lib/debug.r +++ b/ruamoko/lib/debug.r @@ -5,6 +5,6 @@ void coredump (void) = #28; void traceon (void) = #29; void traceoff (void) = #30; void eprint (entity e) = #31; -void dprint (string str) = #25; -void error (string str) = #10; -void objerror (string e) = #11; +void dprint (.../*string str*/) = #25; +void error (.../*string str*/) = #10; +void objerror (.../*string e*/) = #11; diff --git a/ruamoko/lib/message.r b/ruamoko/lib/message.r index 4ddb31571..d01c641e5 100644 --- a/ruamoko/lib/message.r +++ b/ruamoko/lib/message.r @@ -1,7 +1,7 @@ #include void (...) bprint = #23; -void (entity client, string s) sprint = #24; +void (.../*entity client, string s*/) sprint = #24; void (float to, float f) WriteByte = #52; void (float to, float f) WriteChar = #53; void (float to, float f) WriteShort = #54; From 529253e6d9596d865152005aeb0941dc9a4c7e0d Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 10:17:57 +0900 Subject: [PATCH 327/360] [gamecode] Make edict macros more robust to null A null edict pointer should product a null entity, not a segfault. --- include/QF/progs.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index f5ffb1a94..317a1ae19 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -352,10 +352,10 @@ void ED_EntityParseFunction (progs_t *pr); #define PR_edicts(p) (*(p)->pr_edicts) -#define NEXT_EDICT(p,e) ((e) + 1) -#define EDICT_TO_PROG(p,e) ((e)->entnum * (p)->pr_edict_size) +#define NEXT_EDICT(p,e) ((e) ? (e) + 1 : 0) +#define EDICT_TO_PROG(p,e) ((e) ? (e)->entnum * (p)->pr_edict_size : 0) #define PROG_TO_EDICT(p,e) (&PR_edicts(p)[(e) / (p)->pr_edict_size]) -#define NUM_FOR_BAD_EDICT(p,e) ((e)->entnum) +#define NUM_FOR_BAD_EDICT(p,e) ((e) ? (e)->entnum : 0) #ifndef PR_PARANOID_PROGS # define EDICT_NUM(p,n) (PR_edicts (p) + (n)) # define NUM_FOR_EDICT(p,e) NUM_FOR_BAD_EDICT ((p), (e)) From 01345ba6759daabf9d247e9c38ed5e8efb0f401f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 10:24:02 +0900 Subject: [PATCH 328/360] [gamecode] Wrap most uses of PR_RESET_PARAMS with push/pop frame rua_obj was skipped because that looks to be a bit more work and should be a separate commit. This is to avoid the stack getting mangled when calling progs functions with parameters. --- libs/console/menu.c | 8 +++++++- libs/ruamoko/rua_input.c | 1 + libs/ruamoko/rua_stdlib.c | 5 ++++- nq/include/sv_progs.h | 38 ++++++++++++++------------------------ qw/include/sv_progs.h | 38 ++++++++++++++------------------------ 5 files changed, 40 insertions(+), 50 deletions(-) diff --git a/libs/console/menu.c b/libs/console/menu.c index b8e9ccaf7..171de8084 100644 --- a/libs/console/menu.c +++ b/libs/console/menu.c @@ -683,12 +683,14 @@ Menu_Draw (view_t *view) int ret; run_menu_pre (); + PR_PushFrame (&menu_pr_state); PR_RESET_PARAMS (&menu_pr_state); P_INT (&menu_pr_state, 0) = x; P_INT (&menu_pr_state, 1) = y; menu_pr_state.pr_argc = 2; PR_ExecuteProgram (&menu_pr_state, menu->draw); ret = R_INT (&menu_pr_state); + PR_PopFrame (&menu_pr_state); run_menu_post (); if (!ret) return; @@ -718,11 +720,13 @@ Menu_Draw (view_t *view) item = menu->items[menu->cur_item]; if (menu->cursor) { run_menu_pre (); + PR_PushFrame (&menu_pr_state); PR_RESET_PARAMS (&menu_pr_state); P_INT (&menu_pr_state, 0) = x + item->x; P_INT (&menu_pr_state, 1) = y + item->y; menu_pr_state.pr_argc = 2; PR_ExecuteProgram (&menu_pr_state, menu->cursor); + PR_PopFrame (&menu_pr_state); run_menu_post (); } else { r_funcs->Draw_Character (x + item->x, y + item->y, @@ -751,6 +755,7 @@ menu_key_event (const IE_event_t *ie_event) return 0; if (menu->keyevent) { run_menu_pre (); + PR_PushFrame (&menu_pr_state); PR_RESET_PARAMS (&menu_pr_state); P_INT (&menu_pr_state, 0) = key.code; P_INT (&menu_pr_state, 1) = key.unicode; @@ -758,6 +763,7 @@ menu_key_event (const IE_event_t *ie_event) menu_pr_state.pr_argc = 3; PR_ExecuteProgram (&menu_pr_state, menu->keyevent); ret = R_INT (&menu_pr_state); + PR_PopFrame (&menu_pr_state); run_menu_post (); if (ret) return 1; @@ -772,8 +778,8 @@ menu_key_event (const IE_event_t *ie_event) P_INT (&menu_pr_state, 1) = key.code; menu_pr_state.pr_argc = 2; PR_ExecuteProgram (&menu_pr_state, item->func); - PR_PopFrame (&menu_pr_state); ret = R_INT (&menu_pr_state); + PR_PopFrame (&menu_pr_state); run_menu_post (); if (ret) return 1; diff --git a/libs/ruamoko/rua_input.c b/libs/ruamoko/rua_input.c index e54dc73e2..406ce18bc 100644 --- a/libs/ruamoko/rua_input.c +++ b/libs/ruamoko/rua_input.c @@ -283,6 +283,7 @@ rua_listener_func (rua_in_cookie_t *cookie, const void *input) { progs_t *pr = cookie->pr; PR_PushFrame (pr); + PR_RESET_PARAMS (pr); P_POINTER (pr, 0) = cookie->data; P_POINTER (pr, 1) = PR_SetPointer (pr, input);//FIXME check input pr->pr_argc = 2; diff --git a/libs/ruamoko/rua_stdlib.c b/libs/ruamoko/rua_stdlib.c index fa8489d1c..50fd1cc04 100644 --- a/libs/ruamoko/rua_stdlib.c +++ b/libs/ruamoko/rua_stdlib.c @@ -72,12 +72,15 @@ rua_compare (const void *a, const void *b, void *_f) { function_t *f = _f; + PR_PushFrame (f->pr); PR_RESET_PARAMS (f->pr); P_POINTER (f->pr, 0) = PR_SetPointer (f->pr, a); P_POINTER (f->pr, 1) = PR_SetPointer (f->pr, b); f->pr->pr_argc = 2; PR_ExecuteProgram (f->pr, f->func); - return R_INT (f->pr); + int cmp = R_INT (f->pr); + PR_PopFrame (f->pr); + return cmp; } static void diff --git a/nq/include/sv_progs.h b/nq/include/sv_progs.h index 4a74bfb38..79622a1fb 100644 --- a/nq/include/sv_progs.h +++ b/nq/include/sv_progs.h @@ -213,19 +213,29 @@ typedef struct sv_data_s { #define EDICT_FROM_AREA(l) (STRUCT_FROM_LINK(l,sv_data_t,area)->edict) static inline void -sv_pr_touch (edict_t *self, edict_t *other) +sv_pr_exec (edict_t *self, edict_t *other, pr_func_t func) { pr_int_t this; *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, self); *sv_globals.other = EDICT_TO_PROG (&sv_pr_state, other); if ((this = sv_pr_state.fields.this) != -1) { + PR_PushFrame (&sv_pr_state); PR_RESET_PARAMS (&sv_pr_state); P_INT (&sv_pr_state, 0) = E_POINTER (self, this); P_INT (&sv_pr_state, 1) = 0; P_INT (&sv_pr_state, 2) = E_POINTER (other, this); } - PR_ExecuteProgram (&sv_pr_state, SVfunc (self, touch)); + PR_ExecuteProgram (&sv_pr_state, func); + if ((this = sv_pr_state.fields.this) != -1) { + PR_PopFrame (&sv_pr_state); + } +} + +static inline void +sv_pr_touch (edict_t *self, edict_t *other) +{ + sv_pr_exec (self, other, SVfunc (self, touch)); } static inline void @@ -236,33 +246,13 @@ sv_pr_use (edict_t *self, edict_t *other) static inline void sv_pr_think (edict_t *self) { - pr_int_t this; - - *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, self); - *sv_globals.other = 0; - if ((this = sv_pr_state.fields.this) != -1) { - PR_RESET_PARAMS (&sv_pr_state); - P_INT (&sv_pr_state, 0) = E_POINTER (self, this); - P_INT (&sv_pr_state, 1) = 0; - P_INT (&sv_pr_state, 2) = 0; - } - PR_ExecuteProgram (&sv_pr_state, SVfunc (self, think)); + sv_pr_exec (self, 0, SVfunc (self, think)); } static inline void sv_pr_blocked (edict_t *self, edict_t *other) { - pr_int_t this; - - *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, self); - *sv_globals.other = EDICT_TO_PROG (&sv_pr_state, other); - if ((this = sv_pr_state.fields.this) != -1) { - PR_RESET_PARAMS (&sv_pr_state); - P_INT (&sv_pr_state, 0) = E_POINTER (self, this); - P_INT (&sv_pr_state, 1) = 0; - P_INT (&sv_pr_state, 2) = E_POINTER (other, this); - } - PR_ExecuteProgram (&sv_pr_state, SVfunc (self, blocked)); + sv_pr_exec (self, other, SVfunc (self, blocked)); } #endif // __sv_progs_h diff --git a/qw/include/sv_progs.h b/qw/include/sv_progs.h index c158461de..e3ebc6b70 100644 --- a/qw/include/sv_progs.h +++ b/qw/include/sv_progs.h @@ -218,19 +218,29 @@ typedef struct sv_data_s { #define EDICT_FROM_AREA(l) (STRUCT_FROM_LINK(l,sv_data_t,area)->edict) static inline void -sv_pr_touch (edict_t *self, edict_t *other) +sv_pr_exec (edict_t *self, edict_t *other, pr_func_t func) { pr_int_t this; *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, self); *sv_globals.other = EDICT_TO_PROG (&sv_pr_state, other); if ((this = sv_pr_state.fields.this) != -1) { + PR_PushFrame (&sv_pr_state); PR_RESET_PARAMS (&sv_pr_state); P_INT (&sv_pr_state, 0) = E_POINTER (self, this); P_INT (&sv_pr_state, 1) = 0; P_INT (&sv_pr_state, 2) = E_POINTER (other, this); } - PR_ExecuteProgram (&sv_pr_state, SVfunc (self, touch)); + PR_ExecuteProgram (&sv_pr_state, func); + if ((this = sv_pr_state.fields.this) != -1) { + PR_PopFrame (&sv_pr_state); + } +} + +static inline void +sv_pr_touch (edict_t *self, edict_t *other) +{ + sv_pr_exec (self, other, SVfunc (self, touch)); } static inline void @@ -241,33 +251,13 @@ sv_pr_use (edict_t *self, edict_t *other) static inline void sv_pr_think (edict_t *self) { - pr_int_t this; - - *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, self); - *sv_globals.other = 0; - if ((this = sv_pr_state.fields.this) != -1) { - PR_RESET_PARAMS (&sv_pr_state); - P_INT (&sv_pr_state, 0) = E_POINTER (self, this); - P_INT (&sv_pr_state, 1) = 0; - P_INT (&sv_pr_state, 2) = 0; - } - PR_ExecuteProgram (&sv_pr_state, SVfunc (self, think)); + sv_pr_exec (self, 0, SVfunc (self, think)); } static inline void sv_pr_blocked (edict_t *self, edict_t *other) { - pr_int_t this; - - *sv_globals.self = EDICT_TO_PROG (&sv_pr_state, self); - *sv_globals.other = EDICT_TO_PROG (&sv_pr_state, other); - if ((this = sv_pr_state.fields.this) != -1) { - PR_RESET_PARAMS (&sv_pr_state); - P_INT (&sv_pr_state, 0) = E_POINTER (self, this); - P_INT (&sv_pr_state, 1) = 0; - P_INT (&sv_pr_state, 2) = E_POINTER (other, this); - } - PR_ExecuteProgram (&sv_pr_state, SVfunc (self, blocked)); + sv_pr_exec (self, other, SVfunc (self, blocked)); } #endif // __sv_progs_h From 5500d835fed0f78bb9902fd74cd8eaf8c0a00e40 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 10:29:20 +0900 Subject: [PATCH 329/360] [qw] Fix a mangled builtin number When doing the builtin params data change, I had somehow switch multicast's number from 82 to 81. Fortunately, another builtin is also 81, so the VM told me off when I tried to run qw-server :) --- qw/source/sv_pr_cmds.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/qw/source/sv_pr_cmds.c b/qw/source/sv_pr_cmds.c index 9e3ffac8f..e01448de6 100644 --- a/qw/source/sv_pr_cmds.c +++ b/qw/source/sv_pr_cmds.c @@ -2020,7 +2020,7 @@ static builtin_t builtins[] = { bi(logfrag, 79, 2, p(entity), p(entity)), bi(infokey, 80, 2, p(entity), p(string)), - bi(multicast, 81, 2, p(vector), p(float)), + bi(multicast, 82, 2, p(vector), p(float)), bi(testentitypos, QF 92, 1, p(entity)), bi(hullpointcontents, QF 93, 2, p(entity), p(vector)), From 2c0969f9884aef397ef08c72bf6ec4b584eaf61c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 13:01:44 +0900 Subject: [PATCH 330/360] [ruamoko] Rework method call hand-off to preserve the stack This takes care of the problems with PR_RESET_PARAMS (which has recently become just a wrapper for PR_SetupParams) changing the stack and causing PR_CallFunction to save the wrong stack pointer. Message forwarding is currently broken for Ruamoko ISA progs, but that is due to not having a valid pr_argc. However, I do have a plan involving extracting the parameter count from the selector, but that's something for a later commit. Everything else seems to be ok (my little game is working nicely). --- libs/ruamoko/rua_obj.c | 101 +++++++++++++++++++++++++---------------- 1 file changed, 61 insertions(+), 40 deletions(-) diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index a4fc74f9e..bf421ff46 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -59,6 +59,37 @@ #define always_inline inline __attribute__((__always_inline__)) +/* Macros to help with setting up to call a function, and cleaning up + * afterwards. The problem is that PR_CallFunction saves the CURRENT stack + * pointer, which has been adjusted by PR_SetupParams in order to push + * the function arguments. + * + * RUA_CALL_BEGIN and RUA_CALL_END must be used in pairs and this is enforced + * by the unbalanced {}s in the macros. + */ +#define RUA_CALL_BEGIN(pr, argc) \ + { \ + pr_ptr_t saved_stack = 0; \ + int call_depth = (pr)->pr_depth; \ + if ((pr)->globals.stack) { \ + saved_stack = *(pr)->globals.stack; \ + } \ + PR_SetupParams (pr, argc, 1); \ + (pr)->pr_argc = argc; + +#define RUA_CALL_END(pr, imp) \ + if (PR_CallFunction ((pr), (imp), (pr)->pr_return)) { \ + /* the call is to a progs function so a frame was pushed, */ \ + /* ensure the stack pointer is restored on return */ \ + /* if there's no stack, then the following is effectively a */ \ + /* noop */ \ + (pr)->pr_stack[call_depth].stack_ptr = saved_stack; \ + } else if ((pr)->globals.stack) { \ + /* the call was to a builtin, restore the stack */ \ + *(pr)->globals.stack = saved_stack; \ + } \ + } + typedef struct obj_list_s { struct obj_list_s *next; void *data; @@ -1271,39 +1302,45 @@ rua___obj_forward (progs_t *pr) if (obj_reponds_to (probj, obj, fwd_sel)) { imp = get_imp (probj, class, fwd_sel); // forward:(SEL) sel :(@va_list) args - // args is full param list - //FIXME oh for a stack - size_t parm_size = pr->pr_param_size * sizeof(pr_type_t); - size_t size = pr->pr_argc * parm_size; - pr_string_t args_block = PR_AllocTempBlock (pr, size); + // args is full param list as a va_list + pr_string_t args_block = 0; + int argc; + pr_type_t *argv; + if (pr->globals.stack) { + argv = pr->pr_params[0]; + argc = 0; //FIXME extract from sel + } else { + size_t parm_size = pr->pr_param_size * sizeof(pr_type_t); + size_t size = pr->pr_argc * parm_size; + args_block = PR_AllocTempBlock (pr, size); - int argc = pr->pr_argc; - __auto_type argv = (pr_type_t *) PR_GetString (pr, args_block); - // can't memcpy all params because 0 and 1 could be anywhere - memcpy (argv + 0, &P_INT (pr, 0), 4 * sizeof (pr_type_t)); - memcpy (argv + 4, &P_INT (pr, 1), 4 * sizeof (pr_type_t)); - memcpy (argv + 8, &P_INT (pr, 2), (argc - 2) * parm_size); + argc = pr->pr_argc; + argv = (pr_type_t *) PR_GetString (pr, args_block); + // can't memcpy all params because 0 and 1 could be anywhere + memcpy (argv + 0, &P_INT (pr, 0), 4 * sizeof (pr_type_t)); + memcpy (argv + 4, &P_INT (pr, 1), 4 * sizeof (pr_type_t)); + memcpy (argv + 8, &P_INT (pr, 2), (argc - 2) * parm_size); + } - PR_RESET_PARAMS (pr); + RUA_CALL_BEGIN (pr, 4); P_POINTER (pr, 0) = PR_SetPointer (pr, obj); P_POINTER (pr, 1) = PR_SetPointer (pr, fwd_sel); P_POINTER (pr, 2) = PR_SetPointer (pr, sel); P_PACKED (pr, pr_va_list_t, 3).count = argc; P_PACKED (pr, pr_va_list_t, 3).list = PR_SetPointer (pr, argv); - PR_PushTempString (pr, args_block); - PR_CallFunction (pr, imp, pr->pr_return); + if (args_block) { + PR_PushTempString (pr, args_block); + } + RUA_CALL_END (pr, imp); return; } - //FIXME ditto err_sel = sel_register_typed_name (probj, "doesNotRecognize:", "", 0); if (obj_reponds_to (probj, obj, err_sel)) { - imp = get_imp (probj, class, err_sel); - PR_RESET_PARAMS (pr); + RUA_CALL_BEGIN (pr, 3) P_POINTER (pr, 0) = PR_SetPointer (pr, obj); P_POINTER (pr, 1) = PR_SetPointer (pr, err_sel); P_POINTER (pr, 2) = PR_SetPointer (pr, sel); - pr->pr_argc = 3; - PR_CallFunction (pr, imp, pr->pr_return); + RUA_CALL_END (pr, get_imp (probj, class, err_sel)) return; } @@ -1312,16 +1349,13 @@ rua___obj_forward (progs_t *pr) PR_GetString (pr, class->name), PR_GetString (pr, probj->selector_names[sel->sel_id])); - //FIXME ditto err_sel = sel_register_typed_name (probj, "error:", "", 0); if (obj_reponds_to (probj, obj, err_sel)) { - imp = get_imp (probj, class, err_sel); - PR_RESET_PARAMS (pr); + RUA_CALL_BEGIN (pr, 3) P_POINTER (pr, 0) = PR_SetPointer (pr, obj); P_POINTER (pr, 1) = PR_SetPointer (pr, err_sel); P_POINTER (pr, 2) = PR_SetTempString (pr, probj->msg->str); - pr->pr_argc = 3; - PR_CallFunction (pr, imp, pr->pr_return); + RUA_CALL_END (pr, get_imp (probj, class, err_sel)) return; } @@ -1425,32 +1459,19 @@ rua_obj_msg_sendv (progs_t *pr) PR_GetString (pr, probj->selector_names[op->sel_id])); } - pr->pr_argc = count; + RUA_CALL_BEGIN (pr, count) // skip over the first two parameters because receiver and op will // replace them count -= 2; params += 2 * pr->pr_param_size; - pr_ptr_t saved_stack = 0; - int sendv_depth = pr->pr_depth; - if (pr->globals.stack) { - saved_stack = *pr->globals.stack; - } - PR_RESET_PARAMS (pr); + P_POINTER (pr, 0) = obj; P_POINTER (pr, 1) = sel; if (count) { memcpy (&P_INT (pr, 2), params, count * sizeof (pr_type_t) * pr->pr_param_size); } - if (PR_CallFunction (pr, imp, pr->pr_return)) { - // the call is to a progs function so a frame was pushed, ensure - // the stack pointer is restored on return - // if there's no stack, then the following is effectively a noop - pr->pr_stack[sendv_depth].stack_ptr = saved_stack; - } else if (pr->globals.stack) { - // the call was to a builtin, restore the stack - *pr->globals.stack = saved_stack; - } + RUA_CALL_END (pr, imp) } static void From 9cf2740cb4abdf3619843b7fc218abe4a87d4bfb Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 14:07:45 +0900 Subject: [PATCH 331/360] [gamecode] Create a globally accessible hash of type encodings The plan is to use the types to extract the number of parameters for a selector when it is necessary to know the count. However, it'll probably become useful for something else alter (these things seem to always do so). --- include/QF/progs.h | 6 ++++++ libs/gamecode/pr_load.c | 31 +++++++++++++++++++++++++++++-- 2 files changed, 35 insertions(+), 2 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 317a1ae19..cd40e92b7 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1910,6 +1910,12 @@ struct progs_s { struct hashtab_s *field_hash; ///@} + /// \name type encodings + ///@{ + struct hashtab_s *type_hash; + pr_ptr_t type_encodings; + ///@} + /// \name load hooks ///@{ int num_load_funcs; diff --git a/libs/gamecode/pr_load.c b/libs/gamecode/pr_load.c index 1443d1a12..82d07829a 100644 --- a/libs/gamecode/pr_load.c +++ b/libs/gamecode/pr_load.c @@ -46,6 +46,8 @@ #include "QF/sys.h" #include "QF/zone.h" +#include "QF/progs/pr_type.h" + #include "compat.h" VISIBLE cvar_t *pr_boundscheck; @@ -69,6 +71,14 @@ var_get_key (const void *d, void *_pr) return PR_GetString (pr, def->name); } +static const char * +type_get_key (const void *t, void *_pr) +{ + progs_t *pr = (progs_t *) _pr; + __auto_type type = (qfot_type_t *) t; + return PR_GetString (pr, type->encoding); +} + static void file_error (progs_t *pr, const char *path) { @@ -111,7 +121,6 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) dprograms_t progs; byte *base; byte *heap; - pr_def_t *xdefs_def = 0; ddef_t *global_ddefs; ddef_t *field_ddefs; // absolute minimum alignment is 4 bytes @@ -239,6 +248,7 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) Hash_FlushTable (pr->function_hash); Hash_FlushTable (pr->global_hash); Hash_FlushTable (pr->field_hash); + Hash_FlushTable (pr->type_hash); // byte swap the lumps for (i = 0; i < pr->progs->statements.count; i++) { @@ -300,7 +310,22 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) for (i = 0; i < pr->progs->globals.count; i++) ((int *) pr->pr_globals)[i] = LittleLong (((int *) pr->pr_globals)[i]); - xdefs_def = PR_FindGlobal (pr, ".xdefs"); + pr_def_t *types_def = PR_FindGlobal (pr, ".type_encodings"); + if (types_def) { + __auto_type encodings = &G_STRUCT (pr, qfot_type_encodings_t, + types_def->ofs); + pr->type_encodings = encodings->types; + qfot_type_t *type; + for (pr_ptr_t type_ptr = 4; type_ptr < encodings->size; + type_ptr += type->size) { + type = &G_STRUCT (pr, qfot_type_t, pr->type_encodings + type_ptr); + Hash_Add (pr->type_hash, type); + } + } else { + pr->type_encodings = 0; + } + + pr_def_t *xdefs_def = PR_FindGlobal (pr, ".xdefs"); if (xdefs_def) { pr_xdefs_t *xdefs = &G_STRUCT (pr, pr_xdefs_t, xdefs_def->ofs); xdef_t *xdef = &G_STRUCT (pr, xdef_t, xdefs->xdefs); @@ -493,6 +518,8 @@ PR_Init (progs_t *pr) pr->hashlink_freelist); pr->field_hash = Hash_NewTable (1021, var_get_key, 0, pr, pr->hashlink_freelist); + pr->type_hash = Hash_NewTable (1021, type_get_key, 0, pr, + pr->hashlink_freelist); } VISIBLE void From b0810958e73fa8b20be77ff387726bb3f757d0d3 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 14:24:12 +0900 Subject: [PATCH 332/360] [ruamoko] Use encoded selector param count when forwarding This gets message forwarding apparently working, though something isn't quite right as qwaq-app doesn't update properly when I try to step through the program, but that could be an error elsewhere. --- libs/ruamoko/rua_obj.c | 24 +++++++++++++++++++++++- 1 file changed, 23 insertions(+), 1 deletion(-) diff --git a/libs/ruamoko/rua_obj.c b/libs/ruamoko/rua_obj.c index bf421ff46..8f2601066 100644 --- a/libs/ruamoko/rua_obj.c +++ b/libs/ruamoko/rua_obj.c @@ -53,6 +53,7 @@ #include "QF/sys.h" #include "QF/progs/pr_obj.h" +#include "QF/progs/pr_type.h" #include "compat.h" #include "rua_internal.h" @@ -108,6 +109,7 @@ typedef struct probj_resources_s { unsigned selector_index_max; obj_list **selector_sels; pr_string_t *selector_names; + pr_int_t *selector_argc; PR_RESMAP (dtable_t) dtables; dtable_t *dtable_list; pr_func_t obj_forward; @@ -517,9 +519,12 @@ add_sel_name (probj_t *probj, const char *name) size * sizeof (obj_list *)); probj->selector_names = realloc (probj->selector_names, size * sizeof (pr_string_t)); + probj->selector_argc = realloc (probj->selector_argc, + size * sizeof (pr_int_t)); for (i = probj->selector_index_max; i < size; i++) { probj->selector_sels[i] = 0; probj->selector_names[i] = 0; + probj->selector_argc[i] = 0; } probj->selector_index_max = size; } @@ -573,6 +578,15 @@ sel_register_typed_name (probj_t *probj, const char *name, const char *types, l->next = probj->selector_sels[index]; probj->selector_sels[index] = l; + if (sel->sel_types && pr->type_encodings) { + const char *enc = PR_GetString (pr, sel->sel_types); + __auto_type type = (qfot_type_t *) Hash_Find (pr->type_hash, enc); + if (type->meta != ty_basic || type->type != ev_func) { + PR_RunError (pr, "selector type encoing is not a function"); + } + probj->selector_argc[index] = type->func.num_params; + } + if (is_new) Hash_Add (probj->selector_hash, (void *) index); done: @@ -1308,7 +1322,15 @@ rua___obj_forward (progs_t *pr) pr_type_t *argv; if (pr->globals.stack) { argv = pr->pr_params[0]; - argc = 0; //FIXME extract from sel + argc = probj->selector_argc[sel->sel_id]; + if (argc < 0) { + // -ve values indicate varargs functions and is the ones + // complement of the number of real parameters before the + // ellipsis. However, Ruamoko ISA progs pass va_list through + // ... so in the end, a -ve value indicates the total number + // of arguments (including va_list) passed to the function. + argc = -argc; + } } else { size_t parm_size = pr->pr_param_size * sizeof(pr_type_t); size_t size = pr->pr_argc * parm_size; From 208cba85ebc461483b8c8478bd40a24fcbc22775 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 18:37:23 +0900 Subject: [PATCH 333/360] [gamecode] Move return buffer to end of progs memory map With the return buffer in progs_t, it could not be addressed by the progs on 64-bit machines (this was intentional, actually), but in order to get obj_msg_sendv working properly, I needed a way to "bounce" the return address of a calling function to the called function. The cleanest solution I could think of was to add a mode to the with instruction allowing the return pointer to be loaded into a register and then calling the function with a 0 offset for the return value but using the relevant register (next few commits). Testing promptly segfaulted due to the 64-bit offset not fitting into a 32-bit value. --- include/QF/progs.h | 4 ++-- include/QF/progs/pr_comp.h | 1 + libs/gamecode/pr_load.c | 3 +++ 3 files changed, 6 insertions(+), 2 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index cd40e92b7..85b720bbf 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1960,8 +1960,8 @@ struct progs_s { pr_type_t *pr_real_params[PR_MAX_PARAMS]; int pr_param_size; ///< covers both params and return int pr_param_alignment; ///< covers both params and return - pr_type_t pr_return_buffer[32];///< for discarded return values - ///< or returning values to C + pr_type_t *pr_return_buffer; ///< for discarded return values + ///< or returning values to C ///@} /// \name edicts diff --git a/include/QF/progs/pr_comp.h b/include/QF/progs/pr_comp.h index 1012f320d..bc0c1030e 100644 --- a/include/QF/progs/pr_comp.h +++ b/include/QF/progs/pr_comp.h @@ -522,6 +522,7 @@ typedef struct dparmsize_s { #define DEF_SAVEGLOBAL (1<<15) #define PR_MAX_PARAMS 8 +#define PR_MAX_RETURN 32 // maximum size of return value typedef struct dfunction_s { pr_int_t first_statement; // negative numbers are builtins diff --git a/libs/gamecode/pr_load.c b/libs/gamecode/pr_load.c index 82d07829a..c2c3c31d1 100644 --- a/libs/gamecode/pr_load.c +++ b/libs/gamecode/pr_load.c @@ -199,6 +199,8 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) mem_size = pr->pr_edict_area_size * sizeof (pr_type_t); mem_size += pr->progs_size + pr->zone_size + pr->stack_size; + // space for return buffer + mem_size += PR_MAX_RETURN * sizeof (pr_type_t); // +1 for a nul terminator pr->progs = pr->allocate_progs_mem (pr, mem_size + 1); @@ -240,6 +242,7 @@ PR_LoadProgsFile (progs_t *pr, QFile *file, int size) if (pr->globals.stack && pr->stack_bottom) { *pr->globals.stack = pr->globals_size; } + pr->pr_return_buffer = pr->pr_globals + pr->globals_size; if (pr->zone) { PR_Zone_Init (pr); From 078f36a871a0cd244681aded6d48f848ad0d33c9 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 18:42:54 +0900 Subject: [PATCH 334/360] [gamecode] Add "return pointer" mode to with instruction This loads the current return pointer into the specified register. No offset is used (should make that an error, but for now any offset is simply ignored). This is part of the fix for getting obj_msg_sendv to work with return values. --- libs/gamecode/pr_exec.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 4bbf3ca81..bd3879431 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -1989,6 +1989,10 @@ pr_with (progs_t *pr, const dstatement_t *st) // reset pr->pr_bases = (pr_uivec4_t) {}; return; + case 11: + // return pointer + *base = pr->pr_return - pr->pr_globals; + return; } PR_RunError (pr, "Invalid with index: %u", st->a); } From f153e87daac0fbe375c02e7bd5c316b97025853a Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 18:45:54 +0900 Subject: [PATCH 335/360] [qfcc] Use a union to manage specifier bits Having to remember to copy yet another specifier bit was getting tedious, so use a union of a struct with the bitfields and an unsigned int to access them in parallel. Makes for a tidier spec_merge, and one less headache. --- tools/qfcc/include/type.h | 25 +++++++++++++++---------- tools/qfcc/source/qc-parse.y | 8 +------- 2 files changed, 16 insertions(+), 17 deletions(-) diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h index cafa1da91..6c80f9f6d 100644 --- a/tools/qfcc/include/type.h +++ b/tools/qfcc/include/type.h @@ -89,16 +89,21 @@ typedef struct { struct param_s *params; struct symbol_s *sym; ///< for dealing with "int id" etc storage_class_t storage; - unsigned multi_type:1; - unsigned multi_store:1; - unsigned is_signed:1; - unsigned is_unsigned:1; - unsigned is_short:1; - unsigned is_long:1; - unsigned is_typedef:1; - unsigned is_overload:1; - unsigned nosave:1; - unsigned no_va_list:1; + union { + struct { + unsigned multi_type:1; + unsigned multi_store:1; + unsigned is_signed:1; + unsigned is_unsigned:1; + unsigned is_short:1; + unsigned is_long:1; + unsigned is_typedef:1; + unsigned is_overload:1; + unsigned nosave:1; + unsigned no_va_list:1; + }; + unsigned spec_bits; + }; } specifier_t; #define EV_TYPE(type) extern type_t type_##type; diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index 99006c68e..7e7eb9b3a 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -290,13 +290,7 @@ spec_merge (specifier_t spec, specifier_t new) } } spec.sym = new.sym; - spec.is_signed |= new.is_signed; - spec.is_unsigned |= new.is_unsigned; - spec.is_short |= new.is_short; - spec.is_long |= new.is_long; - spec.is_overload |= new.is_overload; - spec.nosave |= new.nosave; - spec.no_va_list |= new.no_va_list; + spec.spec_bits |= new.spec_bits; return spec; } From 8cc6cbc1572fe8fd5c58e2165ba26cb15fe3f9f6 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 18:49:40 +0900 Subject: [PATCH 336/360] [qfcc] Use a union to manage function attributes Same idea as the specifiers, but makes checking function types are the same much easier. --- tools/qfcc/include/type.h | 7 ++++++- tools/qfcc/source/class.c | 2 +- tools/qfcc/source/type.c | 2 +- 3 files changed, 8 insertions(+), 3 deletions(-) diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h index 6c80f9f6d..1c4f9223d 100644 --- a/tools/qfcc/include/type.h +++ b/tools/qfcc/include/type.h @@ -39,7 +39,12 @@ typedef struct ty_func_s { struct type_s *type; int num_params; struct type_s **param_types; - int no_va_list; ///< don't inject va_list for ... function + union { + struct { + unsigned no_va_list:1;///< don't inject va_list for ... function + }; + unsigned attribute_bits; + }; } ty_func_t; typedef struct ty_fldptr_s { diff --git a/tools/qfcc/source/class.c b/tools/qfcc/source/class.c index 42f613c9e..c19f2dd01 100644 --- a/tools/qfcc/source/class.c +++ b/tools/qfcc/source/class.c @@ -90,7 +90,7 @@ type_t type_IMP = { .alignment = 1, .width = 1, .meta = ty_basic, - {{&type_id, -3, IMP_params, 1}}, + {{&type_id, -3, IMP_params, .no_va_list = 1}}, }; type_t type_super = { .type = ev_invalid, diff --git a/tools/qfcc/source/type.c b/tools/qfcc/source/type.c index c9a3c6d75..a695e9f50 100644 --- a/tools/qfcc/source/type.c +++ b/tools/qfcc/source/type.c @@ -379,7 +379,7 @@ types_same (type_t *a, type_t *b) case ev_func: if (a->t.func.type != b->t.func.type || a->t.func.num_params != b->t.func.num_params - || a->t.func.no_va_list != b->t.func.no_va_list) + || a->t.func.attribute_bits != b->t.func.attribute_bits) return 0; count = a->t.func.num_params; if (count < 0) From eee6744656ba016b02fa25fd4942c0770cd9c9ee Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 18:52:02 +0900 Subject: [PATCH 337/360] [qfcc] Use a function to apply function attributes There are too may places where they need to be applied, so making them all use a function will keep things manageable in the future. --- tools/qfcc/source/qc-parse.y | 18 ++++++++++++------ 1 file changed, 12 insertions(+), 6 deletions(-) diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index 7e7eb9b3a..7fd7d658d 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -421,6 +421,12 @@ check_specifiers (specifier_t spec) } } +static void +set_func_type_attrs (type_t *func, specifier_t spec) +{ + func->t.func.no_va_list = spec.no_va_list; +} + %} %expect 0 @@ -486,7 +492,7 @@ external_def ret_type = *type; *type = 0; *type = parse_params (0, $2); - (*type)->t.func.no_va_list = $1.no_va_list; + set_func_type_attrs ((*type), $1); $$.type = find_type (append_type ($1.type, ret_type)); if ($$.type->type != ev_field) $$.params = $2; @@ -527,7 +533,7 @@ function_body symbol_t *sym = $0; specifier_t spec = default_type ($-1, sym); - sym->type->t.func.no_va_list = spec.no_va_list; + set_func_type_attrs (sym->type, spec); sym->type = find_type (append_type (sym->type, spec.type)); $$ = function_symbol (sym, spec.is_overload, 1); } @@ -551,7 +557,7 @@ function_body symbol_t *sym = $0; specifier_t spec = default_type ($-1, sym); - sym->type->t.func.no_va_list = spec.no_va_list; + set_func_type_attrs (sym->type, spec); sym->type = find_type (append_type (sym->type, spec.type)); sym = function_symbol (sym, spec.is_overload, 1); build_builtin_function (sym, $3, 0, spec.storage); @@ -600,7 +606,7 @@ external_decl | function_decl { specifier_t spec = default_type ($0, $1); - $1->type->t.func.no_va_list = spec.no_va_list; + set_func_type_attrs ($1->type, spec); $1->type = find_type (append_type ($1->type, spec.type)); if (spec.is_typedef) { $1->sy_type = sy_type; @@ -1089,7 +1095,7 @@ qc_param_decl type = &(*type)->t.fldptr.type) ; *type = parse_params (*type, $2); - (*type)->t.func.no_va_list = $1.no_va_list; + set_func_type_attrs ((*type), $1); $3->type = find_type ($1.type); if ($3->type->type != ev_field) $3->params = $2; @@ -1168,7 +1174,7 @@ local_decl_list type = &(*type)->t.fldptr.type) ; *type = parse_params (*type, $1); - (*type)->t.func.no_va_list = spec.no_va_list; + set_func_type_attrs ((*type), spec); spec.type = find_type (spec.type); $$ = spec; } From 084c2ccb1f5a775f0f1cf526de4346b23a6f91f9 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 18:55:36 +0900 Subject: [PATCH 338/360] [qfcc] Make is_function_call a little more useful It can (and must) be used one level higher as it checks that the expression is a block and that its result expression is call branch expression. --- tools/qfcc/source/expr.c | 4 ++++ tools/qfcc/source/expr_obj.c | 4 ++-- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 1efde4579..0d96f4fcf 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -1796,6 +1796,10 @@ has_function_call (expr_t *e) int is_function_call (expr_t *e) { + if (e->type != ex_block || !e->e.block.is_call) { + return 0; + } + e = e->e.block.result; return e->type == ex_branch && e->e.branch.type == pr_branch_call; } diff --git a/tools/qfcc/source/expr_obj.c b/tools/qfcc/source/expr_obj.c index 41405c1e4..b2463e4d1 100644 --- a/tools/qfcc/source/expr_obj.c +++ b/tools/qfcc/source/expr_obj.c @@ -249,8 +249,8 @@ message_expr (expr_t *receiver, keywordarg_t *message) if (call->type == ex_error) return receiver; - if (!is_function_call (call->e.block.result)) { - internal_error (call, "unexpected block result type"); + if (!is_function_call (call)) { + internal_error (call, "unexpected call expression type"); } call->e.block.result->e.branch.ret_type = return_type; return call; From 1ce026d16846603894a05b6101af729a963aa720 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 18:58:42 +0900 Subject: [PATCH 339/360] [qfcc] Implement bounced return pointer calls This is achieved by marking a void function with the void_return attribute and then calling that function in an @return expression. @return can be used only inside a void function and only with void functions marked with the void_return attribute. As this is intended for Objective-QC message forwarding, it is deliberately "difficult" to use as returning a larger than expected value is unlikely to end well for the calling function. However, as a convenience, "@return nil" is allowed (in a void function). It always returns an integer (which, of course,can be interpreted as a pointer). This is safe because if the return value is ignored, it will go into the progs return buffer, and if it is not ignored, it is the smallest value that can be returned. --- tools/qfcc/include/expr.h | 4 +++- tools/qfcc/include/type.h | 2 ++ tools/qfcc/source/expr.c | 24 ++++++++++++++++++++++++ tools/qfcc/source/qc-lex.l | 1 + tools/qfcc/source/qc-parse.y | 7 ++++++- tools/qfcc/source/statements.c | 26 ++++++++++++++++++++++++-- 6 files changed, 60 insertions(+), 4 deletions(-) diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h index 5181dfbc6..2b3887ae1 100644 --- a/tools/qfcc/include/expr.h +++ b/tools/qfcc/include/expr.h @@ -236,6 +236,7 @@ typedef struct { typedef struct { struct expr_s *ret_val; + int at_return; ///< return void_return call through void } ex_return_t; typedef struct { @@ -244,7 +245,7 @@ typedef struct { } ex_adjstk_t; typedef struct { - short mode; ///< currently must be 0 + short mode; short reg; ///< base register to load struct expr_s *with; ///< value to load } ex_with_t; @@ -791,6 +792,7 @@ expr_t *goto_expr (expr_t *label); expr_t *jump_table_expr (expr_t *table, expr_t *index); expr_t *call_expr (expr_t *func, expr_t *args, struct type_s *ret_type); expr_t *return_expr (struct function_s *f, expr_t *e); +expr_t *at_return_expr (struct function_s *f, expr_t *e); expr_t *conditional_expr (expr_t *cond, expr_t *e1, expr_t *e2); expr_t *incop_expr (int op, expr_t *e, int postop); expr_t *array_expr (expr_t *array, expr_t *index); diff --git a/tools/qfcc/include/type.h b/tools/qfcc/include/type.h index 1c4f9223d..63fb194e3 100644 --- a/tools/qfcc/include/type.h +++ b/tools/qfcc/include/type.h @@ -42,6 +42,7 @@ typedef struct ty_func_s { union { struct { unsigned no_va_list:1;///< don't inject va_list for ... function + unsigned void_return:1;///< special handling for return value }; unsigned attribute_bits; }; @@ -106,6 +107,7 @@ typedef struct { unsigned is_overload:1; unsigned nosave:1; unsigned no_va_list:1; + unsigned void_return:1; }; unsigned spec_bits; }; diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c index 0d96f4fcf..65eeb2468 100644 --- a/tools/qfcc/source/expr.c +++ b/tools/qfcc/source/expr.c @@ -2477,6 +2477,30 @@ return_expr (function_t *f, expr_t *e) return new_return_expr (e); } +expr_t * +at_return_expr (function_t *f, expr_t *e) +{ + const type_t *ret_type = unalias_type (f->type->t.func.type); + + if (!is_void(ret_type)) { + return error (e, "use of @return in non-void function"); + } + if (is_nil (e)) { + // int or pointer 0 seems reasonable + return new_return_expr (new_int_expr (0)); + } else if (!is_function_call (e)) { + return error (e, "@return value not a function"); + } + expr_t *call_expr = e->e.block.result->e.branch.target; + const type_t *call_type = get_type (call_expr); + if (!is_func (call_type) && !call_type->t.func.void_return) { + return error (e, "@return function not void_return"); + } + expr_t *ret_expr = new_return_expr (e); + ret_expr->e.retrn.at_return = 1; + return ret_expr; +} + expr_t * conditional_expr (expr_t *cond, expr_t *e1, expr_t *e2) { diff --git a/tools/qfcc/source/qc-lex.l b/tools/qfcc/source/qc-lex.l index e0467f1ef..dc30f7748 100644 --- a/tools/qfcc/source/qc-lex.l +++ b/tools/qfcc/source/qc-lex.l @@ -392,6 +392,7 @@ static keyword_t qf_keywords[] = { {"@args", ARGS, 0 }, {"@va_list", TYPE, &type_va_list }, {"@param", TYPE, &type_param }, + {"@return", AT_RETURN, 0 }, {"@cross", CROSS, 0 }, {"@dot", DOT, 0 }, diff --git a/tools/qfcc/source/qc-parse.y b/tools/qfcc/source/qc-parse.y index 7fd7d658d..2874965a2 100644 --- a/tools/qfcc/source/qc-parse.y +++ b/tools/qfcc/source/qc-parse.y @@ -149,7 +149,8 @@ int yylex (void); %token CLASS_NAME NAME %token VALUE STRING -%token LOCAL RETURN WHILE DO IF ELSE FOR BREAK CONTINUE ELLIPSIS +%token LOCAL WHILE DO IF ELSE FOR BREAK CONTINUE +%token RETURN AT_RETURN ELLIPSIS %token NIL GOTO SWITCH CASE DEFAULT ENUM %token ARGS TYPEDEF EXTERN STATIC SYSTEM OVERLOAD NOT ATTRIBUTE %token UNSIGNED SIGNED LONG SHORT @@ -251,6 +252,8 @@ parse_attributes (attribute_t *attr_list) spec.no_va_list = 1; } else if (!strcmp (attr->name, "nosave")) { spec.nosave = 1; + } else if (!strcmp (attr->name, "void_return")) { + spec.void_return = 1; } else { warning (0, "skipping unknown attribute '%s'", attr->name); } @@ -425,6 +428,7 @@ static void set_func_type_attrs (type_t *func, specifier_t spec) { func->t.func.no_va_list = spec.no_va_list; + func->t.func.void_return = spec.void_return; } %} @@ -1420,6 +1424,7 @@ statement | local_def { $$ = $1; } | RETURN opt_expr ';' { $$ = return_expr (current_func, $2); } | RETURN compound_init ';' { $$ = return_expr (current_func, $2); } + | AT_RETURN expr ';' { $$ = at_return_expr (current_func, $2); } | BREAK ';' { $$ = 0; diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c index 6fdefa80b..78a4eb469 100644 --- a/tools/qfcc/source/statements.c +++ b/tools/qfcc/source/statements.c @@ -1427,11 +1427,18 @@ statement_return (sblock_t *sblock, expr_t *e) if (e->e.retrn.ret_val) { expr_t *ret_val = e->e.retrn.ret_val; type_t *ret_type = get_type (ret_val); - s->opa = return_operand (ret_type, e); + + // at_return is used for passing the result of a void_return + // function through void. v6 progs always use .return for the + // return value, so don't need to do anything special: just call + // the function and do a normal void return + if (!e->e.retrn.at_return) { + s->opa = return_operand (ret_type, e); + } sblock = statement_subexpr (sblock, ret_val, &s->opa); } } else { - if (e->e.retrn.ret_val) { + if (!e->e.retrn.at_return && e->e.retrn.ret_val) { expr_t *ret_val = e->e.retrn.ret_val; type_t *ret_type = get_type (ret_val); pr_ushort_t ret_crtl = type_size (ret_type) - 1; @@ -1440,6 +1447,21 @@ statement_return (sblock_t *sblock, expr_t *e) ret_crtl |= mode << 5; s->opc = short_operand (ret_crtl, e); } else { + if (e->e.retrn.at_return) { + expr_t *call = e->e.retrn.ret_val; + if (!call || !is_function_call (call)) { + internal_error (e, "@return with no call"); + } + // FIXME hard-coded reg, and assumes 3 is free + #define REG 3 + expr_t *with = new_with_expr (11, REG, new_short_expr (0)); + def_t *ret_ptr = new_def (0, 0, 0, sc_local); + operand_t *ret_op = def_operand (ret_ptr, &type_void, e); + ret_ptr->reg = REG; + expr_file_line (with, e); + sblock = statement_slist (sblock, with); + sblock = statement_subexpr (sblock, call, &ret_op); + } s->opa = short_operand (0, e); s->opb = short_operand (0, e); s->opc = short_operand (-1, e); // void return From 1fa3acf2d761c64db3a17ef363d50510926ed7e5 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 19:13:46 +0900 Subject: [PATCH 340/360] [ruamoko] Support return values in message forwarding This is the libr side of the return pointer bouncing. --- ruamoko/include/runtime.h | 2 +- ruamoko/lib/Object.r | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ruamoko/include/runtime.h b/ruamoko/include/runtime.h index 276d270fb..849b9be1e 100644 --- a/ruamoko/include/runtime.h +++ b/ruamoko/include/runtime.h @@ -45,7 +45,7 @@ typedef enum { //obj_error_handler obj_set_error_handler (objc_error_handler func); @extern IMP obj_msg_lookup (id receiver, SEL op); @extern IMP obj_msg_lookup_super (Super class, SEL op); -@extern @param obj_msg_sendv (id receiver, SEL op, @va_list args); +@extern @attribute(void_return) void obj_msg_sendv (id receiver, SEL op, @va_list args); @extern BOOL obj_decrement_ref_was_zero (id object); @extern BOOL obj_increment_ref_was_zero (id object); @extern void *obj_malloc (int size); diff --git a/ruamoko/lib/Object.r b/ruamoko/lib/Object.r index 03a1519ad..711721d1d 100644 --- a/ruamoko/lib/Object.r +++ b/ruamoko/lib/Object.r @@ -17,7 +17,7 @@ IMP (id receiver, SEL op) obj_msg_lookup = #0; IMP (Super class, SEL op) obj_msg_lookup_super = #0; id (id receiver, SEL op, ...) obj_msgSend = #0; id obj_msgSend_super (Super *class, SEL op, ...) = #0; -@param (id receiver, SEL op, @va_list args) obj_msg_sendv = #0; +@attribute(void_return) void obj_msg_sendv (id receiver, SEL op, @va_list args) = #0; int obj_decrement_retaincount (id object) = #0; int obj_increment_retaincount (id object) = #0; int obj_get_retaincount (id object) = #0; From 6f4bb0df2cd83327a058b038c84dbe84ec23d37c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 19:14:07 +0900 Subject: [PATCH 341/360] [qfcc] Update sendv test to use @return The return value can't be checked in the test, but it was useful for getting everything actually working. --- tools/qfcc/test/sendv.r | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/qfcc/test/sendv.r b/tools/qfcc/test/sendv.r index 24929992a..aaf7e19cd 100644 --- a/tools/qfcc/test/sendv.r +++ b/tools/qfcc/test/sendv.r @@ -15,7 +15,7 @@ send (id obj, string cmd, string str) params[0].pointer_val = obj; params[1].pointer_val = sel; params[2].string_val = str; - obj_msg_sendv (obj, sel, va_list); + @return obj_msg_sendv (obj, sel, va_list); } @interface Object //just so the runtime doesn't complain From ab8692bd96bb6a1a74dd2201616d5cc6b78fb1d1 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 19:16:06 +0900 Subject: [PATCH 342/360] [qwaq] Allow return values through forwarded messages This was easy to achieve in v6p progs because all return values passed through .return and thus could not be lost. However, Ruamoko progs use a return pointer which can wind up pointed into the void (the return buffer) and thus cause the return value to be lost. Using @return on obj_msg_sendv bounces the return pointer through to the called function. In addition, nil is returned when the forwarding target is nil. --- ruamoko/qwaq/ui/proxyview.r | 4 ++-- ruamoko/qwaq/ui/view.r | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/ruamoko/qwaq/ui/proxyview.r b/ruamoko/qwaq/ui/proxyview.r index 714b3fd9d..c39358092 100644 --- a/ruamoko/qwaq/ui/proxyview.r +++ b/ruamoko/qwaq/ui/proxyview.r @@ -10,9 +10,9 @@ - (void) forward: (SEL) sel : (@va_list) args { if (!view) { - return; + @return nil; } - obj_msg_sendv (view, sel, args); + @return obj_msg_sendv (view, sel, args); } -initWithView:(View *) view diff --git a/ruamoko/qwaq/ui/view.r b/ruamoko/qwaq/ui/view.r index c7fbe58c8..1b7fb4c06 100644 --- a/ruamoko/qwaq/ui/view.r +++ b/ruamoko/qwaq/ui/view.r @@ -264,12 +264,12 @@ updateScreenCursor (View *view) - (void) forward: (SEL) sel : (@va_list) args { if (!textContext) { - return; + @return nil; } if (!__obj_responds_to (textContext, sel)) { [self error: "no implementation for %s", sel_get_name (sel)]; } - obj_msg_sendv (textContext, sel, args); + @return obj_msg_sendv (textContext, sel, args); } - (void) refresh From f4b81d30b04498523dbcf54e609987b3651799b3 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 19:22:08 +0900 Subject: [PATCH 343/360] [qwaq] Pass the correct selector when listeners respond This is actually an old bug in qwaq that was masked by v6p progs parameter passing: it was just luck that event got put in the correct parameter and not trampled until the responder saw it. Ruamoko progs, however, simply lost the event entirely because it never got explicitly passed by the listener implementation. --- ruamoko/qwaq/ui/listener.r | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ruamoko/qwaq/ui/listener.r b/ruamoko/qwaq/ui/listener.r index 8fa43b01f..1776e9ffe 100644 --- a/ruamoko/qwaq/ui/listener.r +++ b/ruamoko/qwaq/ui/listener.r @@ -90,7 +90,7 @@ -(void)respond: (void *) caller_data withObject:(void *)anObject { - [listeners makeObjectsPerformSelector: @selector (respond:) + [listeners makeObjectsPerformSelector: @selector (respond:withObject:) withObject: caller_data withObject: anObject]; } From c10b09d41b1d197684c463f68e1104497b89fa6b Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 20:24:17 +0900 Subject: [PATCH 344/360] [ruamoko] Make RUA_Sprintf more generally useful It now takes the function name to print in error message (passed on to PR_Sprintf) and the argument number of the format string. The variable arguments (in ...) are assumed to be immediately after the format argument. --- include/rua_internal.h | 4 +++- libs/ruamoko/rua_string.c | 14 +++++++------- ruamoko/qwaq/builtins/main.c | 2 +- tools/qfcc/test/test-bi.c | 2 +- 4 files changed, 12 insertions(+), 10 deletions(-) diff --git a/include/rua_internal.h b/include/rua_internal.h index a41177bae..955e6d5e6 100644 --- a/include/rua_internal.h +++ b/include/rua_internal.h @@ -52,7 +52,9 @@ void RUA_String_Init (struct progs_s *pr, int secure); void RUA_QFile_Init (struct progs_s *pr, int secure); void RUA_QFS_Init (struct progs_s *pr, int secure); -void RUA_Sprintf (struct progs_s *pr, struct dstring_s *dstr); +// the variable args are assumed to come immediately after fmt_arg +void RUA_Sprintf (struct progs_s *pr, struct dstring_s *dstr, const char *func, + int fmt_arg); int QFile_AllocHandle (struct progs_s *pr, QFile *file); QFile *QFile_GetFile (struct progs_s *pr, int handle); diff --git a/libs/ruamoko/rua_string.c b/libs/ruamoko/rua_string.c index 314c6d099..f5ccd6d86 100644 --- a/libs/ruamoko/rua_string.c +++ b/libs/ruamoko/rua_string.c @@ -61,14 +61,14 @@ bi_strlen (progs_t *pr) } void -RUA_Sprintf (progs_t *pr, dstring_t *dstr) +RUA_Sprintf (progs_t *pr, dstring_t *dstr, const char *func, int fmt_arg) { - const char *fmt = P_GSTRING (pr, 0); - int count = pr->pr_argc - 1; - pr_type_t **args = pr->pr_params + 1; + const char *fmt = P_GSTRING (pr, fmt_arg); + int count = pr->pr_argc - (fmt_arg + 1); + pr_type_t **args = pr->pr_params + (fmt_arg + 1); if (pr->progs->version == PROG_VERSION) { - __auto_type va_list = &P_PACKED (pr, pr_va_list_t, 1); + __auto_type va_list = &P_PACKED (pr, pr_va_list_t, (fmt_arg + 1)); count = va_list->count; if (count) { args = alloca (count * sizeof (pr_type_t *)); @@ -80,7 +80,7 @@ RUA_Sprintf (progs_t *pr, dstring_t *dstr) } } - PR_Sprintf (pr, dstr, "bi_sprintf", fmt, count, args); + PR_Sprintf (pr, dstr, func, fmt, count, args); } static void @@ -89,7 +89,7 @@ bi_sprintf (progs_t *pr) dstring_t *dstr; dstr = dstring_newstr (); - RUA_Sprintf (pr, dstr); + RUA_Sprintf (pr, dstr, "sprintf", 0); RETURN_STRING (pr, dstr->str); dstring_delete (dstr); } diff --git a/ruamoko/qwaq/builtins/main.c b/ruamoko/qwaq/builtins/main.c index 3a0561035..9bb4d838f 100644 --- a/ruamoko/qwaq/builtins/main.c +++ b/ruamoko/qwaq/builtins/main.c @@ -150,7 +150,7 @@ bi_printf (progs_t *pr) { dstring_t *dstr = dstring_new (); - RUA_Sprintf (pr, dstr); + RUA_Sprintf (pr, dstr, "printf", 0); if (dstr->str) { Sys_Printf ("%s", dstr->str); } diff --git a/tools/qfcc/test/test-bi.c b/tools/qfcc/test/test-bi.c index e12220f8f..1965db082 100644 --- a/tools/qfcc/test/test-bi.c +++ b/tools/qfcc/test/test-bi.c @@ -54,7 +54,7 @@ bi_printf (progs_t *pr) dstring_clear (dstr); } - RUA_Sprintf (pr, dstr); + RUA_Sprintf (pr, dstr, "printf", 0); if (dstr->str) { fputs (dstr->str, stdout); From fbb67419f294226962d0941970277cfefd0f77cc Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 20:26:06 +0900 Subject: [PATCH 345/360] [qwaq] Use RUA_Sprintf for non-va_list printers This fixes the runtime error when the debugger gets to the end of the gcd test program. --- ruamoko/qwaq/builtins/curses.c | 41 +++++++++++----------------------- 1 file changed, 13 insertions(+), 28 deletions(-) diff --git a/ruamoko/qwaq/builtins/curses.c b/ruamoko/qwaq/builtins/curses.c index dfd3d1e40..504939543 100644 --- a/ruamoko/qwaq/builtins/curses.c +++ b/ruamoko/qwaq/builtins/curses.c @@ -46,6 +46,8 @@ #include "QF/ringbuffer.h" #include "QF/sys.h" +#include "rua_internal.h" + #include "ruamoko/qwaq/qwaq.h" #include "ruamoko/qwaq/ui/curses.h" #include "ruamoko/qwaq/ui/rect.h" @@ -763,9 +765,6 @@ static void bi_syncprintf (progs_t *pr) { qwaq_resources_t *res = PR_Resources_Find (pr, "curses"); - const char *fmt = P_GSTRING (pr, 0); - int count = pr->pr_argc - 1; - pr_type_t **args = pr->pr_params + 1; int string_id = qwaq_pipe_acquire_string (&res->commands); dstring_t *print_buffer = qwaq_cmd_string (res, string_id); int command[] = { qwaq_cmd_syncprint, 0, string_id }; @@ -773,7 +772,7 @@ bi_syncprintf (progs_t *pr) command[1] = CMD_SIZE(command); dstring_clearstr (print_buffer); - PR_Sprintf (pr, print_buffer, "mvwaddstr", fmt, count, args); + RUA_Sprintf (pr, print_buffer, "syncprintf", 0); qwaq_pipe_submit (&res->commands, command, command[1]); } @@ -1135,8 +1134,7 @@ bi_mvwaddstr (progs_t *pr) } static void -qwaq_mvwprintf (progs_t *pr, int window_id, int x, int y, const char *fmt, - int count, pr_type_t **args) +qwaq_mvwprintf (progs_t *pr, int window_id, int x, int y, int fmt_arg) { qwaq_resources_t *res = PR_Resources_Find (pr, "curses"); @@ -1151,7 +1149,7 @@ qwaq_mvwprintf (progs_t *pr, int window_id, int x, int y, const char *fmt, command[1] = CMD_SIZE(command); dstring_clearstr (print_buffer); - PR_Sprintf (pr, print_buffer, "mvwaddstr", fmt, count, args); + RUA_Sprintf (pr, print_buffer, "mvwaddstr", fmt_arg); qwaq_pipe_submit (&res->commands, command, command[1]); } @@ -1162,16 +1160,12 @@ bi_mvwprintf (progs_t *pr) int window_id = P_INT (pr, 0); int x = P_INT (pr, 1); int y = P_INT (pr, 2); - const char *fmt = P_GSTRING (pr, 3); - int count = pr->pr_argc - 4; - pr_type_t **args = pr->pr_params + 4; - qwaq_mvwprintf (pr, window_id, x, y, fmt, count, args); + qwaq_mvwprintf (pr, window_id, x, y, 3); } static void -qwaq_wprintf (progs_t *pr, int window_id, const char *fmt, - int count, pr_type_t **args) +qwaq_wprintf (progs_t *pr, int window_id, int fmt_arg) { qwaq_resources_t *res = PR_Resources_Find (pr, "curses"); @@ -1186,7 +1180,7 @@ qwaq_wprintf (progs_t *pr, int window_id, const char *fmt, command[1] = CMD_SIZE(command); dstring_clearstr (print_buffer); - PR_Sprintf (pr, print_buffer, "waddstr", fmt, count, args); + RUA_Sprintf (pr, print_buffer, "wprintf", fmt_arg); qwaq_pipe_submit (&res->commands, command, command[1]); } @@ -1195,11 +1189,8 @@ static void bi_wprintf (progs_t *pr) { int window_id = P_INT (pr, 0); - const char *fmt = P_GSTRING (pr, 1); - int count = pr->pr_argc - 2; - pr_type_t **args = pr->pr_params + 2; - qwaq_wprintf (pr, window_id, fmt, count, args); + qwaq_wprintf (pr, window_id, 1); } static void @@ -1224,7 +1215,7 @@ qwaq_wvprintf (progs_t *pr, int window_id, const char *fmt, pr_va_list_t *args) command[1] = CMD_SIZE(command); dstring_clearstr (print_buffer); - PR_Sprintf (pr, print_buffer, "waddstr", fmt, args->count, list); + PR_Sprintf (pr, print_buffer, "wvprintf", fmt, args->count, list); qwaq_pipe_submit (&res->commands, command, command[1]); } @@ -1283,7 +1274,7 @@ qwaq_mvwvprintf (progs_t *pr, int window_id, int x, int y, command[1] = CMD_SIZE(command); dstring_clearstr (print_buffer); - PR_Sprintf (pr, print_buffer, "waddstr", fmt, args->count, list); + PR_Sprintf (pr, print_buffer, "mvwvprintf", fmt, args->count, list); qwaq_pipe_submit (&res->commands, command, command[1]); } @@ -1667,22 +1658,16 @@ bi__i_TextContext__mvprintf_ (progs_t *pr) { int window_id = P_STRUCT (pr, qwaq_textcontext_t, 0).window; Point *pos = &P_PACKED (pr, Point, 2); - const char *fmt = P_GSTRING (pr, 3); - int count = pr->pr_argc - 4; - pr_type_t **args = pr->pr_params + 4; - qwaq_mvwprintf (pr, window_id, pos->x, pos->y, fmt, count, args); + qwaq_mvwprintf (pr, window_id, pos->x, pos->y, 3); } static void bi__i_TextContext__printf_ (progs_t *pr) { int window_id = P_STRUCT (pr, qwaq_textcontext_t, 0).window; - const char *fmt = P_GSTRING (pr, 2); - int count = pr->pr_argc - 3; - pr_type_t **args = pr->pr_params + 3; - qwaq_wprintf (pr, window_id, fmt, count, args); + qwaq_wprintf (pr, window_id, 2); } static void From 5f2fd3cac0befa927a6c212450acd15afe686747 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sat, 5 Feb 2022 20:36:38 +0900 Subject: [PATCH 346/360] [qfcc] Skip over zero stack adjustment This is a very tiny optimization, but there's no point in adjust the stack if there's no actual adjustment. I didn't bother with it initially because I thought it wouldn't happen (and I was more interested in getting things working first), but it turns out that simple getters that result in a zero adjustment are quite common (70/535 in qwaq-app.dat). --- tools/qfcc/source/function.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index 42f757b9e..c2381d93b 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -801,7 +801,12 @@ build_code_function (symbol_t *fsym, expr_t *state_expr, expr_t *statements) dstatement_t *st = &pr.code->code[func->code]; if (st->op == OP_ADJSTK) { - st->b = -func->params_start; + if (func->params_start) { + st->b = -func->params_start; + } else { + // skip over adjstk so a zero adjustment doesn't get executed + func->code += 1; + } } merge_spaces (space, func->parameters->space, STACK_ALIGN); func->parameters->space = space; From e1ecda9221f143c91f5dd5969581a9691bc59ec4 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 12:20:17 +0900 Subject: [PATCH 347/360] [gamecode] Add unsigned divide and remainder instructions I had forgotten that unsigned division was different from signed division (rather silly of me). However, with some testing and analysis, unsigned true modulo is not needed as it's not possible to have negative inputs and thus it's the same as remainder. --- libs/gamecode/opcodes.py | 15 ++- libs/gamecode/pr_exec.c | 48 +++---- libs/gamecode/test/test-unsigned.c | 204 +++++++++++++++++++++++++++++ 3 files changed, 244 insertions(+), 23 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 3aa2ec324..4bb1b5704 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -8,7 +8,7 @@ bitmap_txt = """ 0 0000 0000 noop 0 0000 0001 adjstk 0 0000 0010 constant -0 1011 nnnn +0 1011 otss udivops 0 1111 s0mm load64 0 1111 s1mm store64 0 1111 n000 @@ -483,6 +483,18 @@ return_formats = { "format": "%Mc5", "types": "ev_void, ev_void, ev_void", } +udivops_formats = { + "opcode": "OP_{op_udiv[o].upper()}_{udiv_type[t]}_{ss+1}", + "mnemonic": "{op_udiv[o]}.{udiv_type[t]}", + "opname": "{op_udiv[o]}", + "widths": "{ss+1}, {ss+1}, {ss+1}", + "types": "{udiv_types[t]}, {udiv_types[t]}, {udiv_types[t]}", + "args": { + "op_udiv": ["div", "rem"], + "udiv_type": ['u', 'U'], + "udiv_types": ["ev_uint", "ev_ulong"], + }, +} vecops_formats = { "opcode": "OP_{op_vop[ooo].upper()}_{vop_type[t]}", "mnemonic": "{op_vop[ooo]}.{vop_type[t]}", @@ -556,6 +568,7 @@ group_map = { "string": string_formats, "swizzle": swizzle_formats, "return": return_formats, + "udivops": udivops_formats, "vecops": vecops_formats, "vecops2": vecops2_formats, "with": with_formats, diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index bd3879431..387ddc28d 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -2974,8 +2974,33 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) OP_cmp(LT, <); // 0 1010 OP_cmp(GT, >); + +#define OP_op_1(OP, T, t, op) \ + case OP_##OP##_##T##_1: \ + OPC(t) = (OPA(t) op OPB(t)); \ + break +#define OP_op_2(OP, T, t, op) \ + case OP_##OP##_##T##_2: \ + OPC(t) = (OPA(t) op OPB(t)); \ + break +#define OP_op_3(OP, T, t, op) \ + case OP_##OP##_##T##_3: \ + VectorCompOp (&OPC(t), &OPA(t), op, &OPB(t)); \ + break; +#define OP_op_4(OP, T, t, op) \ + case OP_##OP##_##T##_4: \ + OPC(t) = (OPA(t) op OPB(t)); \ + break +#define OP_op_T(OP, T, t1, t2, t4, op) \ + OP_op_1 (OP, T, t1, op); \ + OP_op_2 (OP, T, t2, op); \ + OP_op_3 (OP, T, t1, op); \ + OP_op_4 (OP, T, t4, op) // 0 1011 - // spare + OP_op_T (DIV, u, uint, uivec2, uivec4, /); + OP_op_T (DIV, U, ulong, ulvec2, ulvec4, /); + OP_op_T (REM, u, uint, uivec2, uivec4, %); + OP_op_T (REM, U, ulong, ulvec2, ulvec4, %); // 0 1100 OP_cmp(NE, !=); // 0 1101 @@ -3011,27 +3036,6 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) break; // spare -#define OP_op_1(OP, T, t, op) \ - case OP_##OP##_##T##_1: \ - OPC(t) = (OPA(t) op OPB(t)); \ - break -#define OP_op_2(OP, T, t, op) \ - case OP_##OP##_##T##_2: \ - OPC(t) = (OPA(t) op OPB(t)); \ - break -#define OP_op_3(OP, T, t, op) \ - case OP_##OP##_##T##_3: \ - VectorCompOp (&OPC(t), &OPA(t), op, &OPB(t)); \ - break; -#define OP_op_4(OP, T, t, op) \ - case OP_##OP##_##T##_4: \ - OPC(t) = (OPA(t) op OPB(t)); \ - break -#define OP_op_T(OP, T, t1, t2, t4, op) \ - OP_op_1 (OP, T, t1, op); \ - OP_op_2 (OP, T, t2, op); \ - OP_op_3 (OP, T, t1, op); \ - OP_op_4 (OP, T, t4, op) #define OP_op(OP, op) \ OP_op_T (OP, I, int, ivec2, ivec4, op); \ OP_op_T (OP, F, float, vec2, vec4, op); \ diff --git a/libs/gamecode/test/test-unsigned.c b/libs/gamecode/test/test-unsigned.c index e37a84d94..66f68e482 100644 --- a/libs/gamecode/test/test-unsigned.c +++ b/libs/gamecode/test/test-unsigned.c @@ -2,6 +2,63 @@ #include "QF/mathlib.h" +static pr_uivec4_t uint_divop_init[] = { + { 5, -5, 5, -5}, + { 3, 3, -3, -3}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_uivec4_t uint_divop_expect[] = { + { 5, -5, 5, -5}, + { 3, 3, -3, -3}, + { 1, 0x55555553, 0, 0}, + { 2, 2, 5, -5}, +}; + +static dstatement_t uint_divop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 32, -1, 32 }, // dec index + { OP(0, 0, 0, OP_IFAE), 2, 0, 32 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, + { OP(1, 1, 1, OP_DIV_u_1), 0, 4, 8 }, + { OP(1, 1, 1, OP_REM_u_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_JUMP_A), -6, 0, 0 }, +}; + +static dstatement_t uint_divop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 4, 0, 32 }, // index +//loop: + { OP(0, 0, 0, OP_LEA_C), 32, -2, 32 }, // dec index + { OP(0, 0, 0, OP_IFAE), 2, 0, 32 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 32, 1 }, + { OP(1, 1, 1, OP_DIV_u_2), 0, 4, 8 }, + { OP(1, 1, 1, OP_REM_u_2), 0, 4, 12 }, + { OP(1, 1, 1, OP_JUMP_A), -6, 0, 0 }, +}; + +static dstatement_t uint_divop_3a_statements[] = { + { OP(1, 1, 1, OP_DIV_u_3), 0, 4, 8 }, + { OP(1, 1, 1, OP_DIV_u_1), 3, 7, 11 }, + { OP(1, 1, 1, OP_REM_u_3), 0, 4, 12 }, + { OP(1, 1, 1, OP_REM_u_1), 3, 7, 15 }, +}; + +static dstatement_t uint_divop_3b_statements[] = { + { OP(1, 1, 1, OP_DIV_u_1), 0, 4, 8 }, + { OP(1, 1, 1, OP_DIV_u_3), 1, 5, 9 }, + { OP(1, 1, 1, OP_REM_u_1), 0, 4, 12 }, + { OP(1, 1, 1, OP_REM_u_3), 1, 5, 13 }, +}; + +static dstatement_t uint_divop_4_statements[] = { + { OP(1, 1, 1, OP_DIV_u_4), 0, 4, 8 }, + { OP(1, 1, 1, OP_REM_u_4), 0, 4, 12 }, +}; + static pr_uivec4_t uint_cmpop_init[] = { { 5, -5, 5, -5}, { 5, 5, -5, -5}, @@ -95,6 +152,63 @@ static dstatement_t uint_cmpop_4_statements[] = { { OP(1, 1, 1, OP_LE_u_4), 0, 4, 28 }, }; +static pr_ulvec4_t ulong_divop_init[] = { + { 5, -5, 5, -5}, + { 3, 3, -3, -3}, + { 0, 0, 0, 0}, + { 0, 0, 0, 0}, +}; + +static pr_ulvec4_t ulong_divop_expect[] = { + { 5, -5, 5, -5}, + { 3, 3, -3, -3}, + { 1, UINT64_C(0x5555555555555553), 0, 0}, + { 2, 2, 5, -5}, +}; + +static dstatement_t ulong_divop_1_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 64, -2, 64 }, // dec index + { OP(0, 0, 0, OP_IFAE), 2, 0, 64 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, + { OP(1, 1, 1, OP_DIV_U_1), 0, 8, 16 }, + { OP(1, 1, 1, OP_REM_U_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_JUMP_A), -6, 0, 0 }, +}; + +static dstatement_t ulong_divop_2_statements[] = { + { OP(0, 0, 0, OP_LEA_A), 8, 0, 64 }, // init index +//loop: + { OP(0, 0, 0, OP_LEA_C), 64, -4, 64 }, // dec index + { OP(0, 0, 0, OP_IFAE), 2, 0, 64 }, + { OP(0, 0, 0, OP_BREAK), 0, 0, 0 }, + { OP(0, 0, 0, OP_WITH), 4, 64, 1 }, + { OP(1, 1, 1, OP_DIV_U_2), 0, 8, 16 }, + { OP(1, 1, 1, OP_REM_U_2), 0, 8, 24 }, + { OP(1, 1, 1, OP_JUMP_A), -6, 0, 0 }, +}; + +static dstatement_t ulong_divop_3a_statements[] = { + { OP(1, 1, 1, OP_DIV_U_3), 0, 8, 16 }, + { OP(1, 1, 1, OP_DIV_U_1), 6, 14, 22 }, + { OP(1, 1, 1, OP_REM_U_3), 0, 8, 24 }, + { OP(1, 1, 1, OP_REM_U_1), 6, 14, 30 }, +}; + +static dstatement_t ulong_divop_3b_statements[] = { + { OP(1, 1, 1, OP_DIV_U_1), 0, 8, 16 }, + { OP(1, 1, 1, OP_DIV_U_3), 2, 10, 18 }, + { OP(1, 1, 1, OP_REM_U_1), 0, 8, 24 }, + { OP(1, 1, 1, OP_REM_U_3), 2, 10, 26 }, +}; + +static dstatement_t ulong_divop_4_statements[] = { + { OP(1, 1, 1, OP_DIV_U_4), 0, 8, 16 }, + { OP(1, 1, 1, OP_REM_U_4), 0, 8, 24 }, +}; + static pr_ulvec4_t ulong_cmpop_init[] = { { 5, -5, 5, -5}, { 5, 5, -5, -5}, @@ -387,6 +501,51 @@ static dstatement_t ulong_shiftop_4_statements[] = { }; test_t tests[] = { + { + .desc = "uint divop 1", + .extra_globals = 4 * 1, + .num_globals = num_globals(uint_divop_init,uint_divop_expect), + .num_statements = num_statements (uint_divop_1_statements), + .statements = uint_divop_1_statements, + .init_globals = (pr_int_t *) uint_divop_init, + .expect_globals = (pr_int_t *) uint_divop_expect, + }, + { + .desc = "uint divop 2", + .extra_globals = 4 * 1, + .num_globals = num_globals(uint_divop_init,uint_divop_expect), + .num_statements = num_statements (uint_divop_2_statements), + .statements = uint_divop_2_statements, + .init_globals = (pr_int_t *) uint_divop_init, + .expect_globals = (pr_int_t *) uint_divop_expect, + }, + { + .desc = "uint divop 3a", + .extra_globals = 4 * 1, + .num_globals = num_globals(uint_divop_init,uint_divop_expect), + .num_statements = num_statements (uint_divop_3a_statements), + .statements = uint_divop_3a_statements, + .init_globals = (pr_int_t *) uint_divop_init, + .expect_globals = (pr_int_t *) uint_divop_expect, + }, + { + .desc = "uint divop 3b", + .extra_globals = 4 * 1, + .num_globals = num_globals(uint_divop_init,uint_divop_expect), + .num_statements = num_statements (uint_divop_3b_statements), + .statements = uint_divop_3b_statements, + .init_globals = (pr_int_t *) uint_divop_init, + .expect_globals = (pr_int_t *) uint_divop_expect, + }, + { + .desc = "uint divop 4", + .extra_globals = 4 * 1, + .num_globals = num_globals(uint_divop_init,uint_divop_expect), + .num_statements = num_statements (uint_divop_4_statements), + .statements = uint_divop_4_statements, + .init_globals = (pr_int_t *) uint_divop_init, + .expect_globals = (pr_int_t *) uint_divop_expect, + }, { .desc = "uint cmpop 1", .extra_globals = 4 * 1, @@ -432,6 +591,51 @@ test_t tests[] = { .init_globals = (pr_int_t *) uint_cmpop_init, .expect_globals = (pr_int_t *) uint_cmpop_expect, }, + { + .desc = "ulong divop 1", + .extra_globals = 4 * 1, + .num_globals = num_globals(ulong_divop_init,ulong_divop_expect), + .num_statements = num_statements (ulong_divop_1_statements), + .statements = ulong_divop_1_statements, + .init_globals = (pr_int_t *) ulong_divop_init, + .expect_globals = (pr_int_t *) ulong_divop_expect, + }, + { + .desc = "ulong divop 2", + .extra_globals = 4 * 1, + .num_globals = num_globals(ulong_divop_init,ulong_divop_expect), + .num_statements = num_statements (ulong_divop_2_statements), + .statements = ulong_divop_2_statements, + .init_globals = (pr_int_t *) ulong_divop_init, + .expect_globals = (pr_int_t *) ulong_divop_expect, + }, + { + .desc = "ulong divop 3a", + .extra_globals = 4 * 1, + .num_globals = num_globals(ulong_divop_init,ulong_divop_expect), + .num_statements = num_statements (ulong_divop_3a_statements), + .statements = ulong_divop_3a_statements, + .init_globals = (pr_int_t *) ulong_divop_init, + .expect_globals = (pr_int_t *) ulong_divop_expect, + }, + { + .desc = "ulong divop 3b", + .extra_globals = 4 * 1, + .num_globals = num_globals(ulong_divop_init,ulong_divop_expect), + .num_statements = num_statements (ulong_divop_3b_statements), + .statements = ulong_divop_3b_statements, + .init_globals = (pr_int_t *) ulong_divop_init, + .expect_globals = (pr_int_t *) ulong_divop_expect, + }, + { + .desc = "ulong divop 4", + .extra_globals = 4 * 1, + .num_globals = num_globals(ulong_divop_init,ulong_divop_expect), + .num_statements = num_statements (ulong_divop_4_statements), + .statements = ulong_divop_4_statements, + .init_globals = (pr_int_t *) ulong_divop_init, + .expect_globals = (pr_int_t *) ulong_divop_expect, + }, { .desc = "ulong cmpop 1", .extra_globals = 4 * 1, From 95c4cdd1b0f8fe107a1df21dbc5596173e259be8 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 13:12:16 +0900 Subject: [PATCH 348/360] [vulkan] Set frame buffer before calling draw functions This lets them set up their subpass inherit info correctly. QF now renders correctly, albeit painfully slowly, on my VersaPro. --- libs/video/renderer/vid_render_vulkan.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/libs/video/renderer/vid_render_vulkan.c b/libs/video/renderer/vid_render_vulkan.c index 2d7c5bf97..ef35d022a 100644 --- a/libs/video/renderer/vid_render_vulkan.c +++ b/libs/video/renderer/vid_render_vulkan.c @@ -147,6 +147,7 @@ vulkan_R_RenderFrame (SCR_Func *scr_funcs) for (size_t i = 0; i < vulkan_ctx->renderPasses.size; i++) { __auto_type rp = vulkan_ctx->renderPasses.a[i]; __auto_type rpFrame = &rp->frames.a[vulkan_ctx->curFrame]; + frame->framebuffer = rp->framebuffers->a[imageIndex]; rp->draw (rpFrame); } @@ -164,7 +165,6 @@ vulkan_R_RenderFrame (SCR_Func *scr_funcs) __auto_type rpFrame = &rp->frames.a[vulkan_ctx->curFrame]; if (rpFrame->renderpass) { - frame->framebuffer = rp->framebuffers->a[imageIndex]; renderPassInfo.framebuffer = frame->framebuffer, renderPassInfo.renderPass = rp->renderpass; renderPassInfo.clearValueCount = rp->clearValues->size; From 7c6ef06dfb821b21abb89904c1c3cf04f1fbc398 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 19:34:46 +0900 Subject: [PATCH 349/360] [gamecode] Make PF_VarString v6p-only It's not enforced a this stage, and it would be easy enough to handle, but it turns out all the standard quake and quakeworld progs never used ... for the print functions: the behavior of PF_VarString was undocumented and so... tough :P. --- include/QF/progs.h | 2 +- libs/ruamoko/pr_cmds.c | 18 ++---------------- nq/source/sv_pr_cmds.c | 10 +++++----- qw/source/sv_pr_cmds.c | 10 +++++----- qw/source/sv_pr_qwe.c | 6 +++--- 5 files changed, 16 insertions(+), 30 deletions(-) diff --git a/include/QF/progs.h b/include/QF/progs.h index 85b720bbf..0fd8efdfc 100644 --- a/include/QF/progs.h +++ b/include/QF/progs.h @@ -1843,7 +1843,7 @@ extern struct cvar_s *pr_faultchecks; */ ///@{ -char *PF_VarString (progs_t *pr, int first); +char *PF_VarString (progs_t *pr, int first, int count); void PR_Cmds_Init (progs_t *pr); extern const char *pr_gametype; diff --git a/libs/ruamoko/pr_cmds.c b/libs/ruamoko/pr_cmds.c index 93cec016e..1b03f1bad 100644 --- a/libs/ruamoko/pr_cmds.c +++ b/libs/ruamoko/pr_cmds.c @@ -54,27 +54,13 @@ VISIBLE const char *pr_gametype = ""; /* BUILT-IN FUNCTIONS */ VISIBLE char * -PF_VarString (progs_t *pr, int first) +PF_VarString (progs_t *pr, int first, int argc) { char *out, *dst; const char *src; int len, i; - int argc = pr->pr_argc; pr_type_t **argv = pr->pr_params; - if (pr->progs->version == PROG_VERSION) { - __auto_type va_list = &P_PACKED (pr, pr_va_list_t, 0); - argc = va_list->count; - if (argc) { - argv = alloca (argc * sizeof (pr_type_t *)); - for (int i = 0; i < argc; i++) { - argv[i] = &pr->pr_globals[va_list->list + i * 4]; - } - } else { - argv = 0; - } - } - for (len = 0, i = first; i < argc; i++) len += strlen (PR_GetString (pr, argv[i]->string_var)); dst = out = Hunk_TempAlloc (0, len + 1); @@ -367,7 +353,7 @@ PF_eprint (progs_t *pr) static void PF_dprint (progs_t *pr) { - Sys_Printf ("%s", PF_VarString (pr, 0)); + Sys_Printf ("%s", PF_VarString (pr, 0, 1)); } /* diff --git a/nq/source/sv_pr_cmds.c b/nq/source/sv_pr_cmds.c index 38755c8f9..40bd9e72a 100644 --- a/nq/source/sv_pr_cmds.c +++ b/nq/source/sv_pr_cmds.c @@ -71,7 +71,7 @@ PF_error (progs_t *pr) const char *s; edict_t *ed; - s = PF_VarString (pr, 0); + s = PF_VarString (pr, 0, 1); Sys_Printf ("======SERVER ERROR in %s:\n%s\n", PR_GetString (pr, pr->pr_xfunction->descriptor->name), s); ed = PROG_TO_EDICT (pr, *sv_globals.self); @@ -95,7 +95,7 @@ PF_objerror (progs_t *pr) const char *s; edict_t *ed; - s = PF_VarString (pr, 0); + s = PF_VarString (pr, 0, 1); Sys_Printf ("======OBJECT ERROR in %s:\n%s\n", PR_GetString (pr, pr->pr_xfunction->descriptor->name), s); ed = PROG_TO_EDICT (pr, *sv_globals.self); @@ -287,7 +287,7 @@ PF_bprint (progs_t *pr) { const char *s; - s = PF_VarString (pr, 0); + s = PF_VarString (pr, 0, 1); SV_BroadcastPrintf ("%s", s); } @@ -307,7 +307,7 @@ PF_sprint (progs_t *pr) unsigned entnum; entnum = P_EDICTNUM (pr, 0); - s = PF_VarString (pr, 1); + s = PF_VarString (pr, 1, 2); if (entnum < 1 || entnum > svs.maxclients) { Sys_Printf ("tried to sprint to a non-client\n"); @@ -336,7 +336,7 @@ PF_centerprint (progs_t *pr) unsigned entnum; entnum = P_EDICTNUM (pr, 0); - s = PF_VarString (pr, 1); + s = PF_VarString (pr, 1, 2); if (entnum < 1 || entnum > svs.maxclients) { Sys_Printf ("tried to sprint to a non-client\n"); diff --git a/qw/source/sv_pr_cmds.c b/qw/source/sv_pr_cmds.c index e01448de6..f05d3a4cf 100644 --- a/qw/source/sv_pr_cmds.c +++ b/qw/source/sv_pr_cmds.c @@ -73,7 +73,7 @@ PF_error (progs_t *pr) const char *s; edict_t *ed; - s = PF_VarString (pr, 0); + s = PF_VarString (pr, 0, 1); Sys_Printf ("======SERVER ERROR in %s:\n%s\n", PR_GetString (pr, pr->pr_xfunction->descriptor->name), s); ed = PROG_TO_EDICT (pr, *sv_globals.self); @@ -97,7 +97,7 @@ PF_objerror (progs_t *pr) const char *s; edict_t *ed; - s = PF_VarString (pr, 0); + s = PF_VarString (pr, 0, 1); Sys_Printf ("======OBJECT ERROR in %s:\n%s\n", PR_GetString (pr, pr->pr_xfunction->descriptor->name), s); ed = PROG_TO_EDICT (pr, *sv_globals.self); @@ -222,7 +222,7 @@ PF_bprint (progs_t *pr) level = P_FLOAT (pr, 0); - s = PF_VarString (pr, 1); + s = PF_VarString (pr, 1, 2); SV_BroadcastPrintf (level, "%s", s); } @@ -254,7 +254,7 @@ PF_sprint (progs_t *pr) if (client->state == cs_server) //FIXME record to mvd? return; - s = PF_VarString (pr, 2); + s = PF_VarString (pr, 2, 3); SV_ClientPrintf (1, client, level, "%s", s); } @@ -286,7 +286,7 @@ PF_centerprint (progs_t *pr) if (cl->state == cs_server) //FIXME record to mvd? return; - s = PF_VarString (pr, 1); + s = PF_VarString (pr, 1, 2); MSG_ReliableWrite_Begin (&cl->backbuf, svc_centerprint, 2 + strlen (s)); MSG_ReliableWrite_String (&cl->backbuf, s); diff --git a/qw/source/sv_pr_qwe.c b/qw/source/sv_pr_qwe.c index c67f695fc..eb7322800 100644 --- a/qw/source/sv_pr_qwe.c +++ b/qw/source/sv_pr_qwe.c @@ -190,7 +190,7 @@ PF_substr (progs_t *pr) static void PF_strcat (progs_t *pr) { - RETURN_STRING (pr, PF_VarString (pr, 0)); + RETURN_STRING (pr, PF_VarString (pr, 0, pr->pr_argc)); } /* @@ -454,7 +454,7 @@ PF_log (progs_t *pr) name = va (0, "%s/%s.log", qfs_gamedir->dir.def, P_GSTRING (pr, 0)); file = QFS_Open (name, "a"); - text = PF_VarString (pr, 2); + text = PF_VarString (pr, 2, pr->pr_argc); clean_text (text); if (P_FLOAT (pr, 1)) @@ -475,7 +475,7 @@ PF_log (progs_t *pr) static void PF_conprint (progs_t *pr) { - Sys_Printf ("%s", PF_VarString (pr, 0)); + Sys_Printf ("%s", PF_VarString (pr, 0, pr->pr_argc)); } #define QWE (PR_RANGE_QWE << PR_RANGE_SHIFT) | From eba614336da7fbd06e56a7eb37005e22e1ab2de0 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 19:40:16 +0900 Subject: [PATCH 350/360] [gamecode] Add single-component float bitop instructions These add legacy support for basic float bitops (& | ^ ~). Avoiding the instructions would require tot only the source to be converted, but also the servers (as they do access those fields), and this seemed to be too much. --- libs/gamecode/opcodes.py | 21 ++++++++++++++++++++- libs/gamecode/pr_exec.c | 13 ++++++++++++- 2 files changed, 32 insertions(+), 2 deletions(-) diff --git a/libs/gamecode/opcodes.py b/libs/gamecode/opcodes.py index 4bb1b5704..4ec39a71f 100644 --- a/libs/gamecode/opcodes.py +++ b/libs/gamecode/opcodes.py @@ -31,7 +31,7 @@ bitmap_txt = """ 1 1110 c111 stated 1 1111 00mm lea 1 1111 01td vecops2 -1 1111 10nn +1 1111 10oo fbitops 1 1111 1100 convert (conversion mode in st->b) 1 1111 1101 with (mode in st->a, value in st->b, reg in st->c) 1 1111 1110 @@ -186,6 +186,24 @@ convert_formats = { "widths": "-1, 0, -1", "types": "ev_void, ev_short, ev_void", } +fbitops_formats = { + "opcode": "OP_{op_fbit[oo].upper()}_F", + "mnemonic": "{op_fbit[oo]}.f", + "opname": "{op_fbit[oo]}", + "format": "{fbit_fmt[oo]}", + "widths": "1, 1, 1", + "types": "{fbit_types[0]}, {fbit_types[oo==3]}, {fbit_types[0]}", + "args": { + "op_fbit": ["bitand", "bitor", "bitxor", "bitnot"], + "fbit_types": ["ev_float", "ev_invalid"], + "fbit_fmt": [ + "%Ga, %Gb, %gc", + "%Ga, %Gb, %gc", + "%Ga, %Gb, %gc", + "%Ga, %gc", + ], + }, +} hops_formats = { "opcode": "OP_HOPS", "mnemonic": "hops", @@ -548,6 +566,7 @@ group_map = { "compare2": compare2_formats, "constant": constant_formats, "convert": convert_formats, + "fbitops": fbitops_formats, "hops": hops_formats, "jump": jump_formats, "lea": lea_formats, diff --git a/libs/gamecode/pr_exec.c b/libs/gamecode/pr_exec.c index 387ddc28d..c24d35bcf 100644 --- a/libs/gamecode/pr_exec.c +++ b/libs/gamecode/pr_exec.c @@ -3467,7 +3467,18 @@ pr_exec_ruamoko (progs_t *pr, int exitdepth) case OP_V4QMUL_D: OPC(dvec4) = vqmuld (OPA(dvec4), OPB(dvec4)); break; - // 10nn spare + case OP_BITAND_F: + OPC(float) = (int) OPA(float) & (int) OPB(float); + break; + case OP_BITOR_F: + OPC(float) = (int) OPA(float) | (int) OPB(float); + break; + case OP_BITXOR_F: + OPC(float) = (int) OPA(float) ^ (int) OPB(float); + break; + case OP_BITNOT_F: + OPC(float) = ~ (int) OPA(float); + break; case OP_CONV: switch (st->b) { #include "libs/gamecode/pr_convert.cinc" From 748f578856c9c2c66c9c9bab0fcb11429d9365d7 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 19:47:22 +0900 Subject: [PATCH 351/360] [qw] Fix incorrect "server to client" log messages It's not very helpful thinking all the packets are incoming to the client. --- include/netchan.h | 8 +++----- qw/source/cl_demo.c | 2 +- qw/source/cl_main.c | 4 ++-- qw/source/net_packetlog.c | 10 ++++++---- qw/source/sv_main.c | 6 +++--- 5 files changed, 15 insertions(+), 15 deletions(-) diff --git a/include/netchan.h b/include/netchan.h index a71902f64..5fe10eb81 100644 --- a/include/netchan.h +++ b/include/netchan.h @@ -64,12 +64,10 @@ extern struct msg_s *net_message; extern struct cvar_s *qport; -int Net_Log_Init (const char **sound_precache); +int Net_Log_Init (const char **sound_precache, int server); void Net_LogPrintf (const char *fmt, ...) __attribute__ ((format (PRINTF, 1, 2))); -void Log_Incoming_Packet (const byte *p, int len, int has_sequence, - int is_server); -void Log_Outgoing_Packet (const byte *p, int len, int has_sequence, - int is_server); +void Log_Incoming_Packet (const byte *p, int len, int has_sequence); +void Log_Outgoing_Packet (const byte *p, int len, int has_sequence); void Net_LogStop (void *data); void Analyze_Client_Packet (const byte * data, int len, int has_sequence); void Analyze_Server_Packet (const byte * data, int len, int has_sequence); diff --git a/qw/source/cl_demo.c b/qw/source/cl_demo.c index 39d27b249..e82e45d10 100644 --- a/qw/source/cl_demo.c +++ b/qw/source/cl_demo.c @@ -422,7 +422,7 @@ CL_GetMessage (void) if (net_packetlog->int_val) Log_Incoming_Packet (net_message->message->data, - net_message->message->cursize, 1, 0); + net_message->message->cursize, 1); if (cls.demorecording) diff --git a/qw/source/cl_main.c b/qw/source/cl_main.c index 98ed535a5..bfd520246 100644 --- a/qw/source/cl_main.c +++ b/qw/source/cl_main.c @@ -1027,7 +1027,7 @@ CL_ReadPackets (void) if (cls.demoplayback && net_packetlog->int_val) Log_Incoming_Packet (net_message->message->data, - net_message->message->cursize, 0, 0); + net_message->message->cursize, 0); // remote command packet if (*(int *) net_message->message->data == -1) { @@ -1863,7 +1863,7 @@ Host_Init (void) for (i = 0; i < MAX_MODELS; i++) sound_precache[i] = cl.sound_name[i]; - Net_Log_Init (sound_precache); + Net_Log_Init (sound_precache, 0); } CL_HTTP_Init (); diff --git a/qw/source/net_packetlog.c b/qw/source/net_packetlog.c index 72dbe22d0..19314f089 100644 --- a/qw/source/net_packetlog.c +++ b/qw/source/net_packetlog.c @@ -166,6 +166,7 @@ static QFile *Net_PacketLog; static const char **Net_sound_precache; static sizebuf_t _packet; static qmsg_t packet = {0, 0, &_packet}; +static int is_server = 0; static int Net_LogStart (const char *fname) @@ -224,7 +225,7 @@ ascii_dump_buf (unsigned char *buf, int len) } */ void -Log_Incoming_Packet (const byte *p, int len, int has_sequence, int is_server) +Log_Incoming_Packet (const byte *p, int len, int has_sequence) { if (!net_loglevel->int_val) return; @@ -248,7 +249,7 @@ Log_Incoming_Packet (const byte *p, int len, int has_sequence, int is_server) } void -Log_Outgoing_Packet (const byte *p, int len, int has_sequence, int is_server) +Log_Outgoing_Packet (const byte *p, int len, int has_sequence) { if (!net_loglevel->int_val) return; @@ -952,7 +953,7 @@ Analyze_Client_Packet (const byte * data, int len, int has_sequence) static void net_packet_log_f (int length, const void *data, netadr_t to) { - Log_Outgoing_Packet (data, length, 1, 1); + Log_Outgoing_Packet (data, length, 1); } static void @@ -981,8 +982,9 @@ Net_PacketLog_Zap_f (void) } int -Net_Log_Init (const char **sound_precache) +Net_Log_Init (const char **sound_precache, int server) { + is_server = server; Net_sound_precache = sound_precache; _stdout = Qdopen (1, "wt"); // create a QFile of stdout diff --git a/qw/source/sv_main.c b/qw/source/sv_main.c index c97fc8647..1d81ff1af 100644 --- a/qw/source/sv_main.c +++ b/qw/source/sv_main.c @@ -1747,7 +1747,7 @@ void SV_OutOfBand (netadr_t adr, unsigned length, byte *data) { if (net_packetlog->int_val) { - Log_Outgoing_Packet (data, length, 0, 1); + Log_Outgoing_Packet (data, length, 0); } Netchan_OutOfBand (adr, length, data); } @@ -1781,7 +1781,7 @@ SV_ReadPackets (void) while (NET_GetPacket ()) { if (net_packetlog->int_val) Log_Incoming_Packet (net_message->message->data, - net_message->message->cursize, 1, 1); + net_message->message->cursize, 1); if (SV_FilterIP (net_from.ip, &until)) { SV_SendBan (until); // tell them we aren't listening... continue; @@ -2465,7 +2465,7 @@ SV_InitNet (void) Netchan_Init (); net_realtime = &realtime; - Net_Log_Init (sv.sound_precache); + Net_Log_Init (sv.sound_precache, 1); svs.last_heartbeat = -99999; // send immediately sv_net_initialized = 1; From ff08ef3fa3750816dc567dc2fb3907413b978d60 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 19:48:59 +0900 Subject: [PATCH 352/360] [nq,qw] Fix segfault when calling think Think has no "other", and E_POINTER doesn't check for null (by design: it's meant to be as fast as possible). --- nq/include/sv_progs.h | 2 +- qw/include/sv_progs.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/nq/include/sv_progs.h b/nq/include/sv_progs.h index 79622a1fb..4a09f1c5a 100644 --- a/nq/include/sv_progs.h +++ b/nq/include/sv_progs.h @@ -224,7 +224,7 @@ sv_pr_exec (edict_t *self, edict_t *other, pr_func_t func) PR_RESET_PARAMS (&sv_pr_state); P_INT (&sv_pr_state, 0) = E_POINTER (self, this); P_INT (&sv_pr_state, 1) = 0; - P_INT (&sv_pr_state, 2) = E_POINTER (other, this); + P_INT (&sv_pr_state, 2) = other ? E_POINTER (other, this) : 0; } PR_ExecuteProgram (&sv_pr_state, func); if ((this = sv_pr_state.fields.this) != -1) { diff --git a/qw/include/sv_progs.h b/qw/include/sv_progs.h index e3ebc6b70..701475b7e 100644 --- a/qw/include/sv_progs.h +++ b/qw/include/sv_progs.h @@ -229,7 +229,7 @@ sv_pr_exec (edict_t *self, edict_t *other, pr_func_t func) PR_RESET_PARAMS (&sv_pr_state); P_INT (&sv_pr_state, 0) = E_POINTER (self, this); P_INT (&sv_pr_state, 1) = 0; - P_INT (&sv_pr_state, 2) = E_POINTER (other, this); + P_INT (&sv_pr_state, 2) = other ? E_POINTER (other, this) : 0; } PR_ExecuteProgram (&sv_pr_state, func); if ((this = sv_pr_state.fields.this) != -1) { From 5f6e0767d7475c14d115bd27a2b9f7d67e9faffb Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 20:05:35 +0900 Subject: [PATCH 353/360] [qfcc] Make the meaning of vec * vec selectable Currently only via pragma (not command line options), but I needed to test the concept. Converting legacy code is just too error prone. Telling the compiler how to treat the operator makes more sense. When * acts as @dot with Ruamoko progs, the result is automatically aliased as a float as this is the legacy meaning (ie, float result for dot product). --- tools/qfcc/include/options.h | 5 +++++ tools/qfcc/source/expr_binary.c | 10 +++++++-- tools/qfcc/source/options.c | 7 +++++++ tools/qfcc/source/pragma.c | 37 ++++++++++++++++++++++++++++++++- tools/qfcc/source/qc-lex.l | 1 + 5 files changed, 57 insertions(+), 3 deletions(-) diff --git a/tools/qfcc/include/options.h b/tools/qfcc/include/options.h index 0c274bf7c..42b95c257 100644 --- a/tools/qfcc/include/options.h +++ b/tools/qfcc/include/options.h @@ -49,6 +49,10 @@ typedef struct { qboolean promote_float; // promote float through ... } code_options_t; +typedef struct { + int vector_mult; // operation for vector * vector +} math_options_t; + typedef struct { qboolean promote; // Promote warnings to errors qboolean cow; // Warn on copy-on-write detection @@ -93,6 +97,7 @@ typedef struct { typedef struct { code_options_t code; // Code generation options + math_options_t math; // Various math options warn_options_t warnings; // Warning options notice_options_t notices; // Notice options bug_options_t bug; // Bug options diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index 8c2881a64..8077eb372 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -745,9 +745,15 @@ vector_compare (int op, expr_t *e1, expr_t *e2) static expr_t *vector_multiply (int op, expr_t *e1, expr_t *e2) { expr_t *e = new_binary_expr ('*', e1, e2); - if (options.code.progsversion < PROG_VERSION) { + if (options.math.vector_mult == DOT) { // vector * vector is dot product in v6 progs (ick) - e->e.expr.type = &type_float; + e->e.expr.op = DOT; + if (options.code.progsversion == PROG_VERSION) { + e->e.expr.type = &type_vector; + e = new_alias_expr (&type_float, e); + } else { + e->e.expr.type = &type_float; + } } else { // component-wise multiplication e->e.expr.type = &type_vector; diff --git a/tools/qfcc/source/options.c b/tools/qfcc/source/options.c index c8a0a7ff0..c9cec0127 100644 --- a/tools/qfcc/source/options.c +++ b/tools/qfcc/source/options.c @@ -51,6 +51,9 @@ #include "tools/qfcc/include/options.h" #include "tools/qfcc/include/qfcc.h" #include "tools/qfcc/include/strpool.h" +#include "tools/qfcc/include/type.h" + +#include "tools/qfcc/source/qc-parse.h" const char *this_program; const char **source_files; @@ -720,6 +723,8 @@ DecodeArgs (int argc, char **argv) options.code.local_merging = false; if (options.code.vector_components == (qboolean) -1) options.code.vector_components = true; + if (options.math.vector_mult == 0) + options.math.vector_mult = DOT; } if (!options.code.progsversion) options.code.progsversion = PROG_VERSION; @@ -736,6 +741,8 @@ DecodeArgs (int argc, char **argv) options.code.local_merging = true; if (options.code.vector_components == (qboolean) -1) options.code.vector_components = false; + if (options.math.vector_mult == 0) + options.math.vector_mult = options.advanced == 1 ? DOT : '*'; } else { options.code.promote_float = 0; } diff --git a/tools/qfcc/source/pragma.c b/tools/qfcc/source/pragma.c index 9d107edab..2ee208ca5 100644 --- a/tools/qfcc/source/pragma.c +++ b/tools/qfcc/source/pragma.c @@ -50,6 +50,8 @@ #include "tools/qfcc/include/strpool.h" #include "tools/qfcc/include/type.h" +#include "tools/qfcc/source/qc-parse.h" + typedef struct pragma_arg_s { struct pragma_arg_s *next; const char *arg; @@ -139,7 +141,7 @@ static void set_optimize (pragma_arg_t *args) { if (!args) { - warning (0, "missing warn flag"); + warning (0, "missing optimize flag"); return; } const char *flag = args->arg; @@ -153,6 +155,37 @@ set_optimize (pragma_arg_t *args) } } +static pragma_arg_t * +set_vector_mult (pragma_arg_t *args) +{ + if (!args) { + warning (0, "missing vector_mult arg"); + return args; + } + const char *op = args->arg; + if (!strcmp (op, "@dot")) { + options.math.vector_mult = DOT; + } else { + warning (0, "unknown vector_mult arg: %s", op); + } + return args->next; +} + +static void +set_math (pragma_arg_t *args) +{ + if (!args) { + warning (0, "missing math arg"); + return; + } + while (args) { + const char *a = args->arg; + if (!strcmp (a, "vector_mult")) { + args = set_vector_mult (args->next); + } + } +} + void pragma_process () { @@ -175,6 +208,8 @@ pragma_process () set_warn (pragma_args->next); } else if (!strcmp (id, "optimize")) { set_optimize (pragma_args->next); + } else if (!strcmp (id, "math")) { + set_math (pragma_args->next); } else { warning (0, "unknown pragma: '%s'", id); } diff --git a/tools/qfcc/source/qc-lex.l b/tools/qfcc/source/qc-lex.l index dc30f7748..c74dcea4a 100644 --- a/tools/qfcc/source/qc-lex.l +++ b/tools/qfcc/source/qc-lex.l @@ -284,6 +284,7 @@ STRING \"(\\.|[^"\\])*\" BEGIN (GRAB_OTHER); // ignore rest of line } {ID} { pragma_add_arg (yytext); } +@{ID} { pragma_add_arg (yytext); } <*>\r*\n { if (YY_START == PRAGMA) { From afe8c8fca5707e43e9be2b8747865231999c2d0f Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 20:10:47 +0900 Subject: [PATCH 354/360] [qfcc] Auto-demote double for vector scaling This was missed in the switch to an explicit scale instruction. --- tools/qfcc/source/expr_binary.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index 8077eb372..e32e26ead 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -160,7 +160,7 @@ static expr_type_t vector_vector[] = { #define vector_short vector_float static expr_type_t vector_double[] = { - {'*', &type_vector}, + {'*', &type_vector, 0, &type_float, vector_scale}, {'/', 0, 0, 0, inverse_multiply}, {0, 0} }; @@ -488,7 +488,7 @@ static expr_type_t double_float[] = { }; static expr_type_t double_vector[] = { - {'*', &type_vector}, + {'*', &type_vector, &type_float, 0, vector_scale}, {0, 0} }; From 211cd657e0a69fd2bae965ad2bba051bdbcdb1c2 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 20:12:22 +0900 Subject: [PATCH 355/360] [qfcc] Alias entity to int for comparison The ruamoko ISA has no entity comparison operators because an entity is just an int in disguise. --- tools/qfcc/source/expr_binary.c | 17 +++++++++++++++-- 1 file changed, 15 insertions(+), 2 deletions(-) diff --git a/tools/qfcc/source/expr_binary.c b/tools/qfcc/source/expr_binary.c index e32e26ead..832abdc09 100644 --- a/tools/qfcc/source/expr_binary.c +++ b/tools/qfcc/source/expr_binary.c @@ -54,6 +54,7 @@ static expr_t *double_compare (int op, expr_t *e1, expr_t *e2); static expr_t *vector_compare (int op, expr_t *e1, expr_t *e2); static expr_t *vector_multiply (int op, expr_t *e1, expr_t *e2); static expr_t *vector_scale (int op, expr_t *e1, expr_t *e2); +static expr_t *entity_compare (int op, expr_t *e1, expr_t *e2); static expr_type_t string_string[] = { {'+', &type_string}, @@ -166,8 +167,8 @@ static expr_type_t vector_double[] = { }; static expr_type_t entity_entity[] = { - {EQ, &type_int}, - {NE, &type_int}, + {EQ, &type_int, 0, 0, entity_compare}, + {NE, &type_int, 0, 0, entity_compare}, {0, 0} }; @@ -812,6 +813,18 @@ double_compare (int op, expr_t *e1, expr_t *e2) return e; } +static expr_t * +entity_compare (int op, expr_t *e1, expr_t *e2) +{ + if (options.code.progsversion == PROG_VERSION) { + e1 = new_alias_expr (&type_int, e1); + e2 = new_alias_expr (&type_int, e2); + } + expr_t *e = new_binary_expr (op, e1, e2); + e->e.expr.type = &type_int; + return e; +} + static expr_t * invalid_binary_expr (int op, expr_t *e1, expr_t *e2) { From abe43584ffb7d9c58444268fe052f7f3165d5303 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 20:13:59 +0900 Subject: [PATCH 356/360] [qfcc] Create vector component symbols for parameters This got lost when the stack frame setup was converted for Ruamoko. --- tools/qfcc/include/def.h | 3 +++ tools/qfcc/source/def.c | 2 +- tools/qfcc/source/function.c | 2 ++ 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/tools/qfcc/include/def.h b/tools/qfcc/include/def.h index 6ecb5aae8..6892b5d8a 100644 --- a/tools/qfcc/include/def.h +++ b/tools/qfcc/include/def.h @@ -221,6 +221,9 @@ void free_temp_def (def_t *temp); */ void def_to_ddef (def_t *def, ddef_t *ddef, int aux); +void init_vector_components (struct symbol_s *vector_sym, int is_field, + struct symtab_s *symtab); + /** Initialize a def referenced by the given symbol. The symbol is checked for redefinition. A symbol is considered to be diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c index 849723a44..29214b5c3 100644 --- a/tools/qfcc/source/def.c +++ b/tools/qfcc/source/def.c @@ -412,7 +412,7 @@ init_elements (struct def_s *def, expr_t *eles) free_element_chain (&element_chain); } -static void +void init_vector_components (symbol_t *vector_sym, int is_field, symtab_t *symtab) { expr_t *vector_expr; diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index c2381d93b..0c1d8b680 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -542,6 +542,8 @@ create_param (symtab_t *parameters, symbol_t *param) param->s.def = def; param->sy_type = sy_var; symtab_addsymbol (parameters, param); + if (is_vector(param->type) && options.code.vector_components) + init_vector_components (param, 0, parameters); } static void From 548b7fe75359031784c53319a612457356707670 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 20:14:52 +0900 Subject: [PATCH 357/360] [qfcc] Set function file and line when building code I suspect this is an ancient bug that wasn't noticed due to not looking at progs.src compiled code enough, but it makes the first statements of the function point to the correct line instead of a forward declaration. --- tools/qfcc/source/function.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tools/qfcc/source/function.c b/tools/qfcc/source/function.c index 0c1d8b680..e9371ea81 100644 --- a/tools/qfcc/source/function.c +++ b/tools/qfcc/source/function.c @@ -675,6 +675,9 @@ begin_function (symbol_t *sym, const char *nicename, symtab_t *parent, sym->s.func->def->nosave = 1; add_function (sym->s.func); reloc_def_func (sym->s.func, sym->s.func->def); + + sym->s.func->def->file = pr.source_file; + sym->s.func->def->line = pr.source_line; } sym->s.func->code = pr.code->size; From ab4c950c34821ba196939840633d3a5fa5b3d7b7 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 20:46:06 +0900 Subject: [PATCH 358/360] [qw] Print temp entity type number More net_packetlog improvements --- qw/source/net_packetlog.c | 1 + 1 file changed, 1 insertion(+) diff --git a/qw/source/net_packetlog.c b/qw/source/net_packetlog.c index 19314f089..92cddcb38 100644 --- a/qw/source/net_packetlog.c +++ b/qw/source/net_packetlog.c @@ -521,6 +521,7 @@ Parse_Server_Packet (int has_sequence) break; case svc_temp_entity: i = MSG_ReadByte (&packet); + Net_LogPrintf (" type %d", i); switch (i) { case 0: case 1: From 622a2e84f4063dae5a2bef8bc4463b8fabfc0a55 Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 20:51:28 +0900 Subject: [PATCH 359/360] [nq,qw] Update WriteBytes for the Ruamoko ISA More va_list shenanigans. --- nq/source/sv_pr_cmds.c | 18 ++++++++++++++++-- qw/source/sv_pr_cmds.c | 32 +++++++++++++++++++++++--------- 2 files changed, 39 insertions(+), 11 deletions(-) diff --git a/nq/source/sv_pr_cmds.c b/nq/source/sv_pr_cmds.c index 40bd9e72a..eee7778a1 100644 --- a/nq/source/sv_pr_cmds.c +++ b/nq/source/sv_pr_cmds.c @@ -1114,10 +1114,24 @@ static void PF_WriteBytes (progs_t *pr) { int i, p; + int argc = pr->pr_argc - 1; + pr_type_t **argv = pr->pr_params + 1; sizebuf_t *msg = WriteDest (pr); - for (i = 1; i < pr->pr_argc; i++) { - p = P_FLOAT (pr, i); + if (pr->progs->version == PROG_VERSION) { + __auto_type va_list = &P_PACKED (pr, pr_va_list_t, 1); + argc = va_list->count; + if (argc) { + argv = alloca (argc * sizeof (pr_type_t *)); + for (int i = 0; i < argc; i++) { + argv[i] = &pr->pr_globals[va_list->list + i * 4]; + } + } else { + argv = 0; + } + } + for (i = 0; i < argc; i++) { + p = argv[i]->float_var; MSG_WriteByte (msg, p); } } diff --git a/qw/source/sv_pr_cmds.c b/qw/source/sv_pr_cmds.c index f05d3a4cf..f2e9b8a37 100644 --- a/qw/source/sv_pr_cmds.c +++ b/qw/source/sv_pr_cmds.c @@ -1117,11 +1117,24 @@ static void PF_WriteBytes (progs_t *pr) { int i, p; - int count = pr->pr_argc - 1; byte buf[PR_MAX_PARAMS]; + int argc = pr->pr_argc - 1; + pr_type_t **argv = pr->pr_params + 1; - for (i = 0; i < count; i++) { - p = P_FLOAT (pr, i + 1); + if (pr->progs->version == PROG_VERSION) { + __auto_type va_list = &P_PACKED (pr, pr_va_list_t, 1); + argc = va_list->count; + if (argc) { + argv = alloca (argc * sizeof (pr_type_t *)); + for (int i = 0; i < argc; i++) { + argv[i] = &pr->pr_globals[va_list->list + i * 4]; + } + } else { + argv = 0; + } + } + for (i = 0; i < argc; i++) { + p = argv[i]->float_var; buf[i] = p; } @@ -1129,17 +1142,17 @@ PF_WriteBytes (progs_t *pr) client_t *cl = Write_GetClient (pr); if (cl->state != cs_server) { - MSG_ReliableCheckBlock (&cl->backbuf, count); - MSG_ReliableWrite_SZ (&cl->backbuf, buf, count); + MSG_ReliableCheckBlock (&cl->backbuf, argc); + MSG_ReliableWrite_SZ (&cl->backbuf, buf, argc); } if (sv.recorders) { sizebuf_t *dbuf; - dbuf = SVR_WriteBegin (dem_single, cl - svs.clients, count); - SZ_Write (dbuf, buf, count); + dbuf = SVR_WriteBegin (dem_single, cl - svs.clients, argc); + SZ_Write (dbuf, buf, argc); } } else { sizebuf_t *msg = WriteDest (pr); - SZ_Write (msg, buf, count); + SZ_Write (msg, buf, argc); } } @@ -1840,7 +1853,8 @@ PF_SV_ClientNumber (progs_t *pr) int entnum = P_EDICTNUM (pr, 0); client_t *cl = svs.clients + entnum - 1; - if (entnum < 1 || entnum > MAX_CLIENTS || cl->state != cs_server) { + if (entnum < 1 || entnum > MAX_CLIENTS + || cl->state == cs_free || cl->state == cs_zombie) { entnum = 0; // nil entity } R_INT (pr) = entnum - 1; From 76a35c035238c8a0bbe8f9804fb71562ed45db0c Mon Sep 17 00:00:00 2001 From: Bill Currie Date: Sun, 6 Feb 2022 20:59:49 +0900 Subject: [PATCH 360/360] [qfcc] Always test float against 0 for Ruamoko Float is not int, and Ruamoko has only int ifz/ifnz, which will fail for -0.0 (0x80000000 when viewed as an int). And then there's nan, but I haven't seen too many of those in quake. --- tools/qfcc/source/expr_bool.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tools/qfcc/source/expr_bool.c b/tools/qfcc/source/expr_bool.c index 5894e1bad..4d3431769 100644 --- a/tools/qfcc/source/expr_bool.c +++ b/tools/qfcc/source/expr_bool.c @@ -109,8 +109,9 @@ test_expr (expr_t *e) } return e; case ev_float: - if (options.code.fast_float - || options.code.progsversion == PROG_ID_VERSION) { + if (options.code.progsversion < PROG_VERSION + && (options.code.fast_float + || options.code.progsversion == PROG_ID_VERSION)) { if (!is_float(type_default)) { if (is_constant (e)) { return cast_expr (type_default, e);