qf
/
quakeforge
mirror of https://git.code.sf.net/p/quake/quakeforge
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
quakeforge/tools/qfcc/source/opcodes.c

536 lines
14 KiB
C
Raw Blame History

/*
opcodes.c
opcode searching
Copyright (C) 2002 Bill Currie <bill@taniwha.org>
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
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#ifdef HAVE_STRING_H
# include <string.h>
#endif
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#include <stdlib.h>
#include <QF/hash.h>
#include "tools/qfcc/include/diagnostic.h"
#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"
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", "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, {"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 }},
{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 }},
{}
};
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;
static hashtab_t *rua_opcode_void_table;
#define ROTL(x,n) ((((unsigned)(x))<<(n))|((unsigned)(x))>>(32-n))
static uintptr_t
v6p_get_hash (const void *_op, void *_tab)
{
v6p_opcode_t *op = (v6p_opcode_t *) _op;
uintptr_t hash;
hash = ROTL (~op->type_a, 8) + ROTL (~op->type_b, 16)
+ ROTL (~op->type_c, 24);
return hash + Hash_String (op->name);
}
static int
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;
int cmp;
cmp = (opa->type_a == opb->type_a)
&& (opa->type_b == opb->type_b)
&& (opa->type_c == opb->type_c);
return cmp && !strcmp (opa->name, opb->name);
}
static const char *
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)
{
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);
hash += ROTL (~op->widths[0], 12) + ROTL (~op->widths[1], 20)
+ ROTL (~op->widths[2], 28);
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]);
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);
}
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)
{
if ((ot1 == ev_void && ot2 != ev_invalid)
|| ot1 == ot2)
return 1;
return 0;
}
static int
check_operand_width (int ow1, int ow2)
{
return (ow1 == -1 || ow1 == ow2);
}
pr_ushort_t
opcode_get (instruction_t *op)
{
if (options.code.progsversion < PROG_VERSION) {
return (v6p_opcode_t *) op - v6p_opcode_map;
} else {
return (opcode_t *) op - pr_opcodes;
}
}
static v6p_opcode_t *
v6p_opcode_find (const char *name, operand_t *op_a, operand_t *op_b,
operand_t *op_c)
{
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;
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);
if (!op_list)
return op;
for (i = 0; !op && op_list[i]; i++) {
sop = op_list[i];
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);
return 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;
}
etype_t type = low_level_type (op->type);
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;
}
static int
operand_width (const char *opname, 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;
}
// 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;
}
#if 0
if (!strcmp (name, "swizzle")) {
adjust_swizzle_op (&search_op, 0);
adjust_swizzle_op (&search_op, 2);
}
static void
adjust_swizzle_op (opcode_t *op, int opind)
{
// swizzle instructions require both operands to be 4 components (4 or 8
// words) in size with the same alignment.
op->widths[opind] = 4;
if (pr_type_size[op->types[opind]] == 1) {
op->types[opind] = ev_float;
} else if (pr_type_size[op->types[opind]] == 2) {
op->types[opind] = ev_double;
} else {
internal_error (0, "unexpected swizzle op size");
}
}
#endif
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 = "";
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;
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 = {
operand_type (op_a, name),
operand_type (op_b, name),
operand_type (op_c, name),
},
.widths = {
operand_width (opname_a, op_a),
operand_width ("", op_b),
operand_width (opname_c, op_c),
},
};
opcode_t *op;
opcode_t *sop;
void **op_list;
int i;
#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;
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]))) {
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;
}
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 (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;
for (op = pr_v6p_opcodes; op->name; op++) {
num_opcodes++;
}
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 = v6p_opcode_map + i;
*mop = *op;
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.
if (mop->type_a == ev_int)
mop->type_a = ev_float;
if (mop->type_b == ev_int)
mop->type_b = ev_float;
if (mop->type_c == ev_int)
mop->type_c = ev_float;
}
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 (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
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 ();
}
}
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;
} else {
mnemonic = pr_opcodes[st_op].mnemonic;
}
printf ("%04x (%03x)%-8s %d:%04x %d:%04x %d:%04x\n",
addr, st_op & 0x1ff, mnemonic,
(st->op & OP_A_BASE) >> OP_A_SHIFT, st->a,
(st->op & OP_B_BASE) >> OP_B_SHIFT, st->b,
(st->op & OP_C_BASE) >> OP_C_SHIFT, st->c);
}
Reference in New Issue View Git Blame Copy Permalink