qf/quakeforge
0
0
Fork 0
mirror of https://git.code.sf.net/p/quake/quakeforge synced 2024-11-15 01:11:27 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakeforge/tools/qfcc/source/opcodes.c

354 lines
9.9 KiB
C
Raw Normal View History

copyright block work
2002-10-22 14:53:18 +00:00
/*
opcodes.c
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
copyright block work
2002-10-22 14:53:18 +00:00
opcode searching
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
copyright block work
2002-10-22 14:53:18 +00:00
Copyright (C) 2002 Bill Currie <bill@taniwha.org>
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
copyright block work
2002-10-22 14:53:18 +00:00
Author: Bill Currie <bill@taniwha.org>
Date: 2002/06/01
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
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
re-arrange things so __attribute__ and __builtin_expect are properly autoconfiscated so rcsid will continue to work with gcc 3.3
2003-01-15 15:31:36 +00:00
more cmdlib cleanup
2002-06-01 04:41:25 +00:00
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include <stdlib.h>
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
#include <QF/hash.h>
[build] Move to non-recursive make There's still some cleanup to do, but everything seems to be working nicely: `make -j` works, `make distcheck` passes. There is probably plenty of bitrot in the package directories (RPM, debian), though. The vc project files have been removed since those versions are way out of date and quakeforge is pretty much dependent on gcc now anyway. Most of the old Makefile.am files are now Makemodule.am. This should allow for new Makefile.am files that allow local building (to be added on an as-needed bases). The current remaining Makefile.am files are for standalone sub-projects.a The installable bins are currently built in the top-level build directory. This may change if the clutter gets to be too much. While this does make a noticeable difference in build times, the main reason for the switch was to take care of the growing dependency issues: now it's possible to build tools for code generation (eg, using qfcc and ruamoko programs for code-gen).
2020-06-21 14:15:17 +00:00
#include "tools/qfcc/include/opcodes.h"
#include "tools/qfcc/include/options.h"
#include "tools/qfcc/include/qfcc.h"
#include "tools/qfcc/include/statements.h"
#include "tools/qfcc/include/type.h"
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
[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 :)
2022-01-19 09:08:58 +00:00
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>", "if", ev_uint, ev_short, ev_invalid }},
{OP_IFNOT_v6p, {"<IFNOT>", "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 }},
{}
};
[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.
2022-01-07 10:56:15 +00:00
static hashtab_t *v6p_opcode_type_table;
static hashtab_t *v6p_opcode_void_table;
[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 :)
2022-01-19 09:08:58 +00:00
static hashtab_t *v6p_opcode_uint_table;
[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.
2022-01-07 10:56:15 +00:00
static v6p_opcode_t *v6p_opcode_map;
static hashtab_t *rua_opcode_type_table;
static hashtab_t *rua_opcode_void_table;
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
Implement the ROTL macro correctly. Bit rotation requires unsigned ints.
2011-01-26 23:58:50 +00:00
#define ROTL(x,n) ((((unsigned)(x))<<(n))|((unsigned)(x))>>(32-n))
extend the hash api to more easily support general cases
2001-08-16 02:51:53 +00:00
various unsigned long -> uintptr_t conversions
2007-04-04 11:22:48 +00:00
static uintptr_t
[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.
2022-01-07 10:56:15 +00:00
v6p_get_hash (const void *_op, void *_tab)
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
{
[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.
2022-01-02 12:06:14 +00:00
v6p_opcode_t *op = (v6p_opcode_t *) _op;
various unsigned long -> uintptr_t conversions
2007-04-04 11:22:48 +00:00
uintptr_t hash;
extend the hash api to more easily support general cases
2001-08-16 02:51:53 +00:00
Get statments being emitted to the code segment. The first function seems to work fine, but there's a problems with the scope of params causing params to get their knickers in a twist (tangled linked list).
2011-01-25 06:46:48 +00:00
hash = ROTL (~op->type_a, 8) + ROTL (~op->type_b, 16)
+ ROTL (~op->type_c, 24);
fix a bunch of ;; typos
2002-11-20 21:44:04 +00:00
return hash + Hash_String (op->name);
extend the hash api to more easily support general cases
2001-08-16 02:51:53 +00:00
}
static int
[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.
2022-01-07 10:56:15 +00:00
v6p_compare (const void *_opa, const void *_opb, void *unused)
extend the hash api to more easily support general cases
2001-08-16 02:51:53 +00:00
{
[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.
2022-01-02 12:06:14 +00:00
v6p_opcode_t *opa = (v6p_opcode_t *) _opa;
v6p_opcode_t *opb = (v6p_opcode_t *) _opb;
indent whitespace cleanup. not perfect, but a bit more consistent now
2001-12-06 19:49:40 +00:00
int cmp;
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
Get statments being emitted to the code segment. The first function seems to work fine, but there's a problems with the scope of params causing params to get their knickers in a twist (tangled linked list).
2011-01-25 06:46:48 +00:00
cmp = (opa->type_a == opb->type_a)
&& (opa->type_b == opb->type_b)
&& (opa->type_c == opb->type_c);
extend the hash api to more easily support general cases
2001-08-16 02:51:53 +00:00
return cmp && !strcmp (opa->name, opb->name);
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
}
Give special treatment to opcodes that have void operand types.
2011-01-27 05:47:33 +00:00
static const char *
[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.
2022-01-07 10:56:15 +00:00
v6p_get_key (const void *op, void *unused)
Give special treatment to opcodes that have void operand types.
2011-01-27 05:47:33 +00:00
{
[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.
2022-01-02 12:06:14 +00:00
return ((v6p_opcode_t *) op)->name;
Give special treatment to opcodes that have void operand types.
2011-01-27 05:47:33 +00:00
}
[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 :)
2022-01-19 09:08:58 +00:00
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);
}
[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.
2022-01-07 10:56:15 +00:00
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;
}
Give special treatment to opcodes that have void operand types.
2011-01-27 05:47:33 +00:00
static int
check_operand_type (etype_t ot1, etype_t ot2)
{
if ((ot1 == ev_void && ot2 != ev_invalid)
|| ot1 == ot2)
return 1;
return 0;
}
[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.
2022-01-07 10:05:26 +00:00
pr_ushort_t
opcode_get (instruction_t *op)
{
[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.
2022-01-07 10:56:15 +00:00
if (options.code.progsversion < PROG_VERSION) {
return (v6p_opcode_t *) op - v6p_opcode_map;
} else {
return (opcode_t *) op - pr_opcodes;
}
[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.
2022-01-07 10:05:26 +00:00
}
[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.
2022-01-07 10:56:15 +00:00
static v6p_opcode_t *
v6p_opcode_find (const char *name, operand_t *op_a, operand_t *op_b,
operand_t *op_c)
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
{
[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 :)
2022-01-19 09:08:58 +00:00
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;
[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.
2022-01-02 12:06:14 +00:00
v6p_opcode_t *op;
v6p_opcode_t *sop;
Give special treatment to opcodes that have void operand types.
2011-01-27 05:47:33 +00:00
void **op_list;
int i;
[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 :)
2022-01-19 09:08:58 +00:00
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);
Give special treatment to opcodes that have void operand types.
2011-01-27 05:47:33 +00:00
if (op)
[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.
2022-01-07 10:56:15 +00:00
return op;
op_list = Hash_FindList (v6p_opcode_void_table, name);
Give special treatment to opcodes that have void operand types.
2011-01-27 05:47:33 +00:00
if (!op_list)
[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.
2022-01-07 10:56:15 +00:00
return op;
Give special treatment to opcodes that have void operand types.
2011-01-27 05:47:33 +00:00
for (i = 0; !op && op_list[i]; i++) {
sop = op_list[i];
[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 :)
2022-01-19 09:08:58 +00:00
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))
Give special treatment to opcodes that have void operand types.
2011-01-27 05:47:33 +00:00
op = sop;
}
free (op_list);
[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.
2022-01-07 10:56:15 +00:00
return op;
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
}
[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.
2022-01-07 10:56:15 +00:00
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)
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
{
[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.
2022-01-02 12:06:14 +00:00
const v6p_opcode_t *op;
v6p_opcode_t *mop;
Add some very evil pragmas. The evil comment is not just "pragmas are bad, ok?", but switching between advanced, extended and tradtitional modes when compiling truly is evil and not guaranteed to work. However, I needed it to make building test cases easier (it's mostly ok to go from advanced to extended or tradtional, but going the other way will probably cause all sorts of fun). In the process, opcode_init now copies the opcode table data rather than modifying it.
2012-11-22 11:42:00 +00:00
[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.
2022-01-07 10:56:15 +00:00
if (v6p_opcode_type_table) {
Hash_FlushTable (v6p_opcode_void_table);
Hash_FlushTable (v6p_opcode_type_table);
[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 :)
2022-01-19 09:08:58 +00:00
Hash_FlushTable (v6p_opcode_uint_table);
Add some very evil pragmas. The evil comment is not just "pragmas are bad, ok?", but switching between advanced, extended and tradtitional modes when compiling truly is evil and not guaranteed to work. However, I needed it to make building test cases easier (it's mostly ok to go from advanced to extended or tradtional, but going the other way will probably cause all sorts of fun). In the process, opcode_init now copies the opcode table data rather than modifying it.
2012-11-22 11:42:00 +00:00
} else {
[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.
2022-01-07 10:56:15 +00:00
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);
[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 :)
2022-01-19 09:08:58 +00:00
v6p_opcode_uint_table = Hash_NewTable (1021, 0, 0, 0, 0);
Hash_SetHashCompare (v6p_opcode_uint_table,
v6p_uint_get_hash, v6p_uint_compare);
Add some very evil pragmas. The evil comment is not just "pragmas are bad, ok?", but switching between advanced, extended and tradtitional modes when compiling truly is evil and not guaranteed to work. However, I needed it to make building test cases easier (it's mostly ok to go from advanced to extended or tradtional, but going the other way will probably cause all sorts of fun). In the process, opcode_init now copies the opcode table data rather than modifying it.
2012-11-22 11:42:00 +00:00
}
[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.
2021-12-31 10:16:02 +00:00
int num_opcodes = 0;
[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.
2022-01-02 12:06:14 +00:00
for (op = pr_v6p_opcodes; op->name; op++) {
[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.
2021-12-31 10:16:02 +00:00
num_opcodes++;
}
[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.
2022-01-07 10:56:15 +00:00
if (!v6p_opcode_map) {
v6p_opcode_map = calloc (num_opcodes, sizeof (v6p_opcode_t));
[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.
2021-12-31 10:16:02 +00:00
}
for (int i = 0; i < num_opcodes; i++) {
[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.
2022-01-02 12:06:14 +00:00
op = pr_v6p_opcodes + i;
qfcc: Preparation for getopt.
2001-10-26 06:43:56 +00:00
if (op->min_version > options.code.progsversion)
pr_comp.h: define PROG_ID_VERSION as 6 and redefine PROG_VERSION as 0x00fff001 (0.fff.001) for the new qc features. pr_edict.c: support version 6 and version 0.fff.001 progs qfcc.h: add version field to options_t add min_version field to opcode_t pr_opcode.c: set the minumum version of each opcode (gee, that table is getting ugly) filter out opcodes with too high a min_version when initializing the opcode hash tables. qfcc.c: update help output. accept --id to limit code generation to id compatable (ver 6) progs. default progs generation to 0.fff.001
2001-06-09 06:25:33 +00:00
continue;
[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.
2022-01-07 10:56:15 +00:00
mop = v6p_opcode_map + i;
Add some very evil pragmas. The evil comment is not just "pragmas are bad, ok?", but switching between advanced, extended and tradtitional modes when compiling truly is evil and not guaranteed to work. However, I needed it to make building test cases easier (it's mostly ok to go from advanced to extended or tradtional, but going the other way will probably cause all sorts of fun). In the process, opcode_init now copies the opcode table data rather than modifying it.
2012-11-22 11:42:00 +00:00
*mop = *op;
Convert all integer operands to float for v6 progs. Converting only opc is no longer enough.
2011-01-27 00:00:11 +00:00
if (options.code.progsversion == PROG_ID_VERSION) {
// v6 progs have no concept of integer, but the QF engine
// 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.
[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.
2022-01-18 04:21:06 +00:00
if (mop->type_a == ev_int)
Add some very evil pragmas. The evil comment is not just "pragmas are bad, ok?", but switching between advanced, extended and tradtitional modes when compiling truly is evil and not guaranteed to work. However, I needed it to make building test cases easier (it's mostly ok to go from advanced to extended or tradtional, but going the other way will probably cause all sorts of fun). In the process, opcode_init now copies the opcode table data rather than modifying it.
2012-11-22 11:42:00 +00:00
mop->type_a = ev_float;
[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.
2022-01-18 04:21:06 +00:00
if (mop->type_b == ev_int)
Add some very evil pragmas. The evil comment is not just "pragmas are bad, ok?", but switching between advanced, extended and tradtitional modes when compiling truly is evil and not guaranteed to work. However, I needed it to make building test cases easier (it's mostly ok to go from advanced to extended or tradtional, but going the other way will probably cause all sorts of fun). In the process, opcode_init now copies the opcode table data rather than modifying it.
2012-11-22 11:42:00 +00:00
mop->type_b = ev_float;
[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.
2022-01-18 04:21:06 +00:00
if (mop->type_c == ev_int)
Add some very evil pragmas. The evil comment is not just "pragmas are bad, ok?", but switching between advanced, extended and tradtitional modes when compiling truly is evil and not guaranteed to work. However, I needed it to make building test cases easier (it's mostly ok to go from advanced to extended or tradtional, but going the other way will probably cause all sorts of fun). In the process, opcode_init now copies the opcode table data rather than modifying it.
2012-11-22 11:42:00 +00:00
mop->type_c = ev_float;
Convert all integer operands to float for v6 progs. Converting only opc is no longer enough.
2011-01-27 00:00:11 +00:00
}
[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.
2022-01-07 10:56:15 +00:00
Hash_AddElement (v6p_opcode_type_table, mop);
Add some very evil pragmas. The evil comment is not just "pragmas are bad, ok?", but switching between advanced, extended and tradtitional modes when compiling truly is evil and not guaranteed to work. However, I needed it to make building test cases easier (it's mostly ok to go from advanced to extended or tradtional, but going the other way will probably cause all sorts of fun). In the process, opcode_init now copies the opcode table data rather than modifying it.
2012-11-22 11:42:00 +00:00
if (mop->type_a == ev_void || mop->type_b == ev_void
|| mop->type_c == ev_void)
[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.
2022-01-07 10:56:15 +00:00
Hash_Add (v6p_opcode_void_table, mop);
}
[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 :)
2022-01-19 09:08:58 +00:00
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);
}
}
[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.
2022-01-07 10:56:15 +00:00
}
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 ();
re-write the opcode selection to be a hash table lookup and statment generation to get the opcode from the table record rather than the location within the table (ewww). gives a nice speed boost /and/ makes the opcode table easier to maintain.
2001-06-04 02:41:45 +00:00
}
}
Reference in a new issue Copy permalink