mirror of
https://git.code.sf.net/p/quake/quakeforge
synced 2024-11-26 22:31:05 +00:00
6d5e8922a5
I never liked the various hacks I had come up with for representing resource handles in Ruamoko. Structs with an int were awkward to test, pointers and ints could be modified, etc etc. The new @handle keyword (@ used to keep handle free for use) works just like struct, union and enum in syntax, but creates an opaque type suitable for a 32-bit handle. The backing type is a function so v6 progs can use it without (all the necessary opcodes exist) and no modifications were needed for type-checking in binary expressions, but only assignment and comparisons are supported, and (of course) nil. Tested using cbuf_t and QFile: seems to work as desired. I had considered 64-bit handles, but really, if more than 4G resource objects are needed, I'm not sure QF can handle the game. However, that limit is per resource manager, not total.
2006 lines
49 KiB
C
2006 lines
49 KiB
C
/*
|
|
pr_debug.c
|
|
|
|
progs debugging
|
|
|
|
Copyright (C) 2001 Bill Currie <bill@tanwiha.org>
|
|
|
|
Author: Bill Currie <bill@tanwiha.org>
|
|
Date: 2001/7/13
|
|
|
|
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 <ctype.h>
|
|
#include <sys/types.h>
|
|
#include <stdlib.h>
|
|
#include <inttypes.h>
|
|
|
|
#include "QF/fbsearch.h"
|
|
#include "QF/cvar.h"
|
|
#include "QF/dstring.h"
|
|
#include "QF/hash.h"
|
|
#include "QF/heapsort.h"
|
|
#include "QF/mathlib.h"
|
|
#include "QF/progs.h"
|
|
#include "QF/qendian.h"
|
|
#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"
|
|
#include "QF/progs/pr_type.h"
|
|
#include "QF/simd/types.h"
|
|
|
|
#include "compat.h"
|
|
|
|
typedef struct {
|
|
char *text;
|
|
size_t len;
|
|
} line_t;
|
|
|
|
typedef struct {
|
|
char *name;
|
|
char *text;
|
|
off_t size;
|
|
line_t *lines;
|
|
pr_uint_t num_lines;
|
|
progs_t *pr;
|
|
} file_t;
|
|
|
|
typedef struct compunit_s {
|
|
const char *file;
|
|
pr_compunit_t *unit;
|
|
} compunit_t;
|
|
|
|
typedef struct {
|
|
const char *file;
|
|
pr_uint_t line;
|
|
} func_key_t;
|
|
|
|
typedef struct prdeb_resources_s {
|
|
progs_t *pr;
|
|
dstring_t *string;
|
|
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;
|
|
pr_auxfunction_t **auxfunction_map;
|
|
pr_func_t *sorted_functions;
|
|
pr_lineno_t *linenos;
|
|
pr_def_t *local_defs;
|
|
pr_def_t *type_encodings_def;
|
|
qfot_type_t void_type;
|
|
qfot_type_t *type_encodings[ev_type_count];
|
|
pr_def_t *debug_defs;
|
|
pr_type_t *debug_data;
|
|
hashtab_t *debug_syms;
|
|
hashtab_t *compunits; // by source file
|
|
PR_RESMAP (compunit_t) compmap; // handy allocation/freeing
|
|
hashtab_t *file_hash;
|
|
} prdeb_resources_t;
|
|
|
|
typedef struct {
|
|
progs_t *pr;
|
|
dstring_t *dstr;
|
|
} pr_debug_data_t;
|
|
|
|
int pr_debug;
|
|
static cvar_t pr_debug_cvar = {
|
|
.name = "pr_debug",
|
|
.description =
|
|
"enable progs debugging",
|
|
.default_value = "0",
|
|
.flags = CVAR_NONE,
|
|
.value = { .type = &cexpr_int, .value = &pr_debug },
|
|
};
|
|
char *pr_source_path;
|
|
static cvar_t pr_source_path_cvar = {
|
|
.name = "pr_source_path",
|
|
.description =
|
|
"where to look (within gamedir) for source files",
|
|
.default_value = ".",
|
|
.flags = CVAR_NONE,
|
|
.value = { .type = 0, .value = &pr_source_path },
|
|
};
|
|
static char *source_path_string;
|
|
static char **source_paths;
|
|
|
|
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,
|
|
void *_data);
|
|
static void pr_debug_enum_view (qfot_type_t *type, pr_type_t *value,
|
|
void *_data);
|
|
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_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 *
|
|
file_get_key (const void *_f, void *unused)
|
|
{
|
|
return ((file_t*)_f)->name;
|
|
}
|
|
|
|
static void
|
|
file_free (void *_f, void *unused)
|
|
{
|
|
file_t *f = (file_t*)_f;
|
|
progs_t *pr = f->pr;
|
|
|
|
free (f->lines);
|
|
((progs_t *) pr)->free_progs_mem (pr, f->text);
|
|
free (f->name);
|
|
free (f);
|
|
}
|
|
|
|
static const char *
|
|
def_get_key (const void *d, void *p)
|
|
{
|
|
__auto_type def = (pr_def_t *) d;
|
|
__auto_type pr = (progs_t *) p;
|
|
return PR_GetString (pr, def->name);
|
|
}
|
|
|
|
static const char *
|
|
compunit_get_key (const void *cu, void *p)
|
|
{
|
|
__auto_type compunit = (compunit_t *) cu;
|
|
return compunit->file;
|
|
}
|
|
|
|
static void
|
|
source_path_f (void *data, const cvar_t *cvar)
|
|
{
|
|
int i;
|
|
char *s;
|
|
|
|
if (source_path_string) {
|
|
free (source_path_string);
|
|
}
|
|
source_path_string = strdup (pr_source_path);
|
|
if (source_paths) {
|
|
free (source_paths);
|
|
}
|
|
// i starts at 2 because an empty path is equivalent to "." and the
|
|
// list is null terminated
|
|
for (i = 2, s = source_path_string; *s; s++) {
|
|
if (*s == ';') {
|
|
i++;
|
|
}
|
|
}
|
|
source_paths = malloc (i * sizeof (char *));
|
|
source_paths[0] = source_path_string;
|
|
// i starts at one because the first path is in 0 and any additional
|
|
// paths come after, then the null terminator
|
|
for (i = 1, s = source_path_string; *s; s++) {
|
|
if (*s == ';') {
|
|
*s = 0;
|
|
source_paths[i++] = s + 1;
|
|
}
|
|
}
|
|
source_paths[i] = 0;
|
|
}
|
|
|
|
#define RUP(x,a) (((x) + ((a) - 1)) & ~((a) - 1))
|
|
static pr_short_t __attribute__((pure))
|
|
pr_debug_type_size (const progs_t *pr, const qfot_type_t *type)
|
|
{
|
|
pr_short_t size;
|
|
qfot_type_t *aux_type;
|
|
switch (type->meta) {
|
|
case ty_basic:
|
|
case ty_handle:
|
|
return pr_type_size[type->type];
|
|
case ty_struct:
|
|
case ty_union:
|
|
size = 0;
|
|
for (pr_int_t i = 0; i < type->strct.num_fields; i++) {
|
|
const qfot_var_t *field = &type->strct.fields[i];
|
|
aux_type = &G_STRUCT (pr, qfot_type_t, field->type);
|
|
size = max (size,
|
|
field->offset + pr_debug_type_size (pr, aux_type));
|
|
}
|
|
return size;
|
|
case ty_enum:
|
|
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);
|
|
return type->array.size * size;
|
|
case ty_class:
|
|
return 1; //FIXME or should it return sizeof class struct?
|
|
case ty_alias:
|
|
aux_type = &G_STRUCT (pr, qfot_type_t, type->alias.aux_type);
|
|
return pr_debug_type_size (pr, aux_type);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static qfot_type_t *
|
|
get_def_type (progs_t *pr, pr_def_t *def, qfot_type_t *type)
|
|
{
|
|
if (!def->type_encoding) {
|
|
// no type encoding, so use basic type data to fill in and return
|
|
// the dummy encoding
|
|
memset (type, 0, sizeof (*type));
|
|
type->type = def->type;
|
|
} else {
|
|
type = &G_STRUCT (pr, qfot_type_t, def->type_encoding);
|
|
if (!def->size) {
|
|
def->size = pr_debug_type_size (pr, type);
|
|
}
|
|
}
|
|
return type;
|
|
}
|
|
|
|
static pr_def_t
|
|
parse_expression (progs_t *pr, const char *expr, int conditional)
|
|
{
|
|
script_t *es;
|
|
char *e;
|
|
pr_type_t *expr_ptr;
|
|
pr_def_t d;
|
|
|
|
d.ofs = 0;
|
|
d.type = ev_invalid;
|
|
d.name = 0;
|
|
es = Script_New ();
|
|
Script_Start (es, "<console>", expr);
|
|
expr_ptr = 0;
|
|
es->single = "{}()':[].";
|
|
if (Script_GetToken (es, 1)) {
|
|
if (strequal (es->token->str, "[")) {
|
|
edict_t *ent;
|
|
pr_def_t *field;
|
|
|
|
if (!Script_GetToken (es, 1))
|
|
goto error;
|
|
ent = EDICT_NUM (pr, strtol (es->token->str, &e, 0));
|
|
if (e == es->token->str)
|
|
goto error;
|
|
if (!Script_GetToken (es, 1) && !strequal (es->token->str, "]" ))
|
|
goto error;
|
|
if (!Script_GetToken (es, 1) && !strequal (es->token->str, "." ))
|
|
goto error;
|
|
if (!Script_GetToken (es, 1))
|
|
goto error;
|
|
field = PR_FindField (pr, es->token->str);
|
|
if (!field)
|
|
goto error;
|
|
d = *field;
|
|
expr_ptr = &E_fld (ent, field->ofs);
|
|
d.ofs = PR_SetPointer (pr, expr_ptr);
|
|
} else if (isdigit ((byte) es->token->str[0])) {
|
|
expr_ptr = PR_GetPointer (pr, strtol (es->token->str, 0, 0));
|
|
d.type = ev_void;
|
|
d.ofs = PR_SetPointer (pr, expr_ptr);
|
|
} else {
|
|
pr_def_t *global = PR_FindGlobal (pr, es->token->str);
|
|
if (!global)
|
|
goto error;
|
|
d = *global;
|
|
}
|
|
if (conditional) {
|
|
es->single = "{}()':[]";
|
|
pr->wp_conditional = 0;
|
|
if (Script_TokenAvailable (es, 1)) {
|
|
if (!Script_GetToken (es, 1)
|
|
&& !strequal (es->token->str, "==" ))
|
|
goto error;
|
|
if (!Script_GetToken (es, 1))
|
|
goto error;
|
|
PR_PTR (int, &pr->wp_val) = strtol (es->token->str, &e, 0);
|
|
if (e == es->token->str)
|
|
goto error;
|
|
if (*e == '.' || *e == 'e' || *e == 'E')
|
|
PR_PTR (float, &pr->wp_val) = strtod (es->token->str, &e);
|
|
pr->wp_conditional = 1;
|
|
}
|
|
}
|
|
if (Script_TokenAvailable (es, 1))
|
|
Sys_Printf ("ignoring tail\n");
|
|
}
|
|
error:
|
|
if (es->error) {
|
|
Sys_Printf ("%s\n", es->error);
|
|
}
|
|
Script_Delete (es);
|
|
return d;
|
|
}
|
|
|
|
static void
|
|
pr_debug_clear (progs_t *pr, void *data)
|
|
{
|
|
__auto_type res = (prdeb_resources_t *) data;
|
|
|
|
dstring_clearstr (res->string);
|
|
dstring_clearstr (res->dva);
|
|
dstring_clearstr (res->line);
|
|
dstring_clearstr (res->dstr);
|
|
|
|
if (res->debug)
|
|
pr->free_progs_mem (pr, res->debug);
|
|
Hash_FlushTable (res->file_hash);
|
|
Hash_FlushTable (res->debug_syms);
|
|
Hash_FlushTable (res->compunits);
|
|
PR_RESRESET (res->compmap);
|
|
res->debug = 0;
|
|
res->auxfunctions = 0;
|
|
if (res->auxfunction_map)
|
|
pr->free_progs_mem (pr, res->auxfunction_map);
|
|
res->auxfunction_map = 0;
|
|
if (res->sorted_functions)
|
|
pr->free_progs_mem (pr, res->sorted_functions);
|
|
res->sorted_functions = 0;
|
|
res->linenos = 0;
|
|
res->local_defs = 0;
|
|
|
|
pr->watch = 0;
|
|
pr->wp_conditional = 0;
|
|
PR_PTR (int, &pr->wp_val) = 0;
|
|
|
|
for (int i = 0; i < ev_type_count; i++ ) {
|
|
res->type_encodings[i] = &res->void_type;
|
|
}
|
|
}
|
|
|
|
static void
|
|
pr_debug_destroy (progs_t *pr, void *_res)
|
|
{
|
|
__auto_type res = (prdeb_resources_t *) _res;
|
|
|
|
dstring_delete (res->string);
|
|
dstring_delete (res->dva);
|
|
dstring_delete (res->line);
|
|
dstring_delete (res->dstr);
|
|
va_destroy_context (res->va);
|
|
|
|
Hash_DelTable (res->file_hash);
|
|
Hash_DelTable (res->debug_syms);
|
|
Hash_DelTable (res->compunits);
|
|
|
|
PR_RESDELMAP (res->compmap);
|
|
|
|
pr->pr_debug_resources = 0;
|
|
|
|
free (res);
|
|
}
|
|
|
|
static file_t *
|
|
PR_Load_Source_File (progs_t *pr, const char *fname)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
char *l, *p, **dir;
|
|
file_t *f = Hash_Find (res->file_hash, fname);
|
|
|
|
if (f)
|
|
return f;
|
|
f = calloc (1, sizeof (file_t));
|
|
if (!f)
|
|
return 0;
|
|
for (dir = source_paths; *dir && !f->text; dir++) {
|
|
f->text = pr->load_file (pr, dsprintf (res->dva, "%s%s%s", *dir,
|
|
**dir ? "/" : "", fname),
|
|
&f->size);
|
|
}
|
|
if (!f->text) {
|
|
pr->file_error (pr, fname);
|
|
} else {
|
|
for (f->num_lines = 1, l = f->text; *l; l++)
|
|
if (*l == '\n')
|
|
f->num_lines++;
|
|
}
|
|
f->name = strdup (fname);
|
|
if (!f->name) {
|
|
pr->free_progs_mem (pr, f->text);
|
|
free (f);
|
|
return 0;
|
|
}
|
|
if (f->num_lines) {
|
|
f->lines = malloc (f->num_lines * sizeof (line_t));
|
|
if (!f->lines) {
|
|
free (f->name);
|
|
pr->free_progs_mem (pr, f->text);
|
|
free (f);
|
|
return 0;
|
|
}
|
|
f->lines[0].text = f->text;
|
|
for (f->num_lines = 0, l = f->text; *l; l++) {
|
|
if (*l == '\n') {
|
|
for (p = l; p > f->lines[f->num_lines].text
|
|
&& isspace((byte) p[-1]); p--)
|
|
;
|
|
f->lines[f->num_lines].len = p - f->lines[f->num_lines].text;
|
|
f->lines[++f->num_lines].text = l + 1;
|
|
}
|
|
}
|
|
f->lines[f->num_lines].len = l - f->lines[f->num_lines].text;
|
|
f->num_lines++;
|
|
}
|
|
f->pr = pr;
|
|
Hash_Add (res->file_hash, f);
|
|
return f;
|
|
}
|
|
|
|
static void
|
|
byteswap_def (pr_def_t *def)
|
|
{
|
|
def->type = LittleShort (def->type);
|
|
def->size = LittleShort (def->size);
|
|
def->ofs = LittleLong (def->ofs);
|
|
def->name = LittleLong (def->name);
|
|
def->type_encoding = LittleLong (def->type_encoding);
|
|
}
|
|
|
|
static compunit_t *
|
|
new_compunit (prdeb_resources_t *res)
|
|
{
|
|
return PR_RESNEW (res->compmap);
|
|
}
|
|
|
|
static void
|
|
process_compunit (prdeb_resources_t *res, pr_def_t *def)
|
|
{
|
|
progs_t *pr = res->pr;
|
|
__auto_type compunit = (pr_compunit_t *) (res->debug_data + def->ofs);
|
|
|
|
for (unsigned i = 0; i < compunit->num_files; i++) {
|
|
compunit_t *cu = new_compunit (res);
|
|
cu->unit = compunit;
|
|
cu->file = PR_GetString (pr, compunit->files[i]);
|
|
Hash_Add (res->compunits, cu);
|
|
}
|
|
}
|
|
|
|
static int
|
|
def_compare_sort (const void *_da, const void *_db, void *_res)
|
|
{
|
|
pr_def_t da = *(const pr_def_t *)_da;
|
|
pr_def_t db = *(const pr_def_t *)_db;
|
|
return da.ofs - db.ofs;
|
|
}
|
|
|
|
static int
|
|
func_compare_sort (const void *_fa, const void *_fb, void *_res)
|
|
{
|
|
prdeb_resources_t *res = _res;
|
|
progs_t *pr = res->pr;
|
|
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);
|
|
if (cmp) {
|
|
return cmp;
|
|
}
|
|
pr_auxfunction_t *fa_aux = res->auxfunction_map[fa];
|
|
pr_auxfunction_t *fb_aux = res->auxfunction_map[fb];
|
|
pr_uint_t fa_line = fa_aux ? fa_aux->source_line : 0;
|
|
pr_uint_t fb_line = fb_aux ? fb_aux->source_line : 0;
|
|
return fa_line - fb_line;
|
|
}
|
|
|
|
static int
|
|
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;
|
|
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) {
|
|
return cmp;
|
|
}
|
|
pr_auxfunction_t *f_aux = res->auxfunction_map[f];
|
|
pr_uint_t f_line = f_aux ? f_aux->source_line : 0;
|
|
return key->line - f_line;
|
|
}
|
|
|
|
VISIBLE void
|
|
PR_DebugSetSym (progs_t *pr, pr_debug_header_t *debug)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
|
|
res->auxfunctions = (pr_auxfunction_t*)((char*)debug + debug->auxfunctions);
|
|
res->linenos = (pr_lineno_t*)((char*)debug + debug->linenos);
|
|
res->local_defs = (pr_def_t*)((char*)debug + debug->locals);
|
|
res->debug_defs = (pr_def_t*)((char*)debug + debug->debug_defs);
|
|
res->debug_data = (pr_type_t*)((char*)debug + debug->debug_data);
|
|
|
|
size_t size;
|
|
size = pr->progs->functions.count * sizeof (pr_auxfunction_t *);
|
|
res->auxfunction_map = pr->allocate_progs_mem (pr, size);
|
|
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->functions.count; i++) {
|
|
res->auxfunction_map[i] = 0;
|
|
res->sorted_functions[i] = i;
|
|
}
|
|
|
|
qfot_type_encodings_t *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,
|
|
res->type_encodings_def->ofs);
|
|
type_encodings = encodings->types;
|
|
}
|
|
|
|
for (pr_uint_t i = 0; i < debug->num_auxfunctions; i++) {
|
|
if (type_encodings) {
|
|
res->auxfunctions[i].return_type += type_encodings;
|
|
}
|
|
res->auxfunction_map[res->auxfunctions[i].function] =
|
|
&res->auxfunctions[i];
|
|
heapsort_r (res->local_defs + res->auxfunctions[i].local_defs,
|
|
res->auxfunctions[i].num_locals, sizeof (pr_def_t),
|
|
def_compare_sort, res);
|
|
}
|
|
heapsort_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++) {
|
|
if (type_encodings) {
|
|
res->local_defs[i].type_encoding += type_encodings;
|
|
}
|
|
}
|
|
|
|
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) {
|
|
def->type_encoding += type_encodings;
|
|
}
|
|
Hash_Add (res->debug_syms, def);
|
|
if (def->name == compunit_str) {
|
|
process_compunit (res, def);
|
|
}
|
|
}
|
|
|
|
if (encodings) {
|
|
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, type_encodings + type_ptr);
|
|
if (type->meta == ty_basic
|
|
&& (unsigned) type->type < ev_type_count) {
|
|
res->type_encodings[type->type] = type;
|
|
}
|
|
}
|
|
}
|
|
|
|
res->debug = debug;
|
|
}
|
|
|
|
VISIBLE int
|
|
PR_LoadDebug (progs_t *pr)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
char *sym_path;
|
|
const char *path_end, *sym_file;
|
|
off_t debug_size;
|
|
pr_uint_t i;
|
|
pr_def_t *def;
|
|
pr_type_t *str = 0;
|
|
pr_debug_header_t *debug;
|
|
|
|
res->debug = 0;
|
|
|
|
if (!pr_debug)
|
|
return 1;
|
|
|
|
def = PR_FindGlobal (pr, ".debug_file");
|
|
if (def)
|
|
str = &pr->pr_globals[def->ofs];
|
|
|
|
if (!str)
|
|
return 1;
|
|
res->debugfile = PR_GetString (pr, PR_PTR (string, str));
|
|
sym_file = QFS_SkipPath (res->debugfile);
|
|
path_end = QFS_SkipPath (pr->progs_name);
|
|
sym_path = malloc (strlen (sym_file) + (path_end - pr->progs_name) + 1);
|
|
strncpy (sym_path, pr->progs_name, path_end - pr->progs_name);
|
|
strcpy (sym_path + (path_end - pr->progs_name), sym_file);
|
|
debug = pr->load_file (pr, sym_path, &debug_size);
|
|
if (!debug) {
|
|
Sys_Printf ("can't load %s for debug info\n", sym_path);
|
|
free (sym_path);
|
|
return 1;
|
|
}
|
|
debug->version = LittleLong (debug->version);
|
|
if (debug->version != PROG_DEBUG_VERSION) {
|
|
Sys_Printf ("ignoring %s with unsupported version %x.%03x.%03x\n",
|
|
sym_path,
|
|
(debug->version >> 24) & 0xff,
|
|
(debug->version >> 12) & 0xfff,
|
|
debug->version & 0xfff);
|
|
free (sym_path);
|
|
return 1;
|
|
}
|
|
debug->crc = LittleShort (debug->crc);
|
|
if (debug->crc != pr->crc) {
|
|
Sys_Printf ("ignoring %s that doesn't match %s. (CRCs: "
|
|
"sym:%d dat:%d)\n",
|
|
sym_path, pr->progs_name, debug->crc, pr->crc);
|
|
free (sym_path);
|
|
return 1;
|
|
}
|
|
free (sym_path);
|
|
debug->you_tell_me_and_we_will_both_know = LittleShort
|
|
(debug->you_tell_me_and_we_will_both_know);
|
|
debug->auxfunctions = LittleLong (debug->auxfunctions);
|
|
debug->num_auxfunctions = LittleLong (debug->num_auxfunctions);
|
|
debug->linenos = LittleLong (debug->linenos);
|
|
debug->num_linenos = LittleLong (debug->num_linenos);
|
|
debug->locals = LittleLong (debug->locals);
|
|
debug->num_locals = LittleLong (debug->num_locals);
|
|
debug->debug_defs = LittleLong (debug->debug_defs);
|
|
debug->num_debug_defs = LittleLong (debug->num_debug_defs);
|
|
debug->debug_data = LittleLong (debug->debug_data);
|
|
debug->debug_data_size = LittleLong (debug->debug_data_size);
|
|
|
|
__auto_type auxfuncs = (pr_auxfunction_t*)((char*)debug
|
|
+ debug->auxfunctions);
|
|
for (i = 0; i < debug->num_auxfunctions; i++) {
|
|
auxfuncs[i].function = LittleLong (auxfuncs[i].function);
|
|
auxfuncs[i].source_line = LittleLong (auxfuncs[i].source_line);
|
|
auxfuncs[i].line_info = LittleLong (auxfuncs[i].line_info);
|
|
auxfuncs[i].local_defs = LittleLong (auxfuncs[i].local_defs);
|
|
auxfuncs[i].num_locals = LittleLong (auxfuncs[i].num_locals);
|
|
}
|
|
|
|
__auto_type linenos = (pr_lineno_t*)((char*)debug + debug->linenos);
|
|
for (i = 0; i < debug->num_linenos; i++) {
|
|
linenos[i].fa.func = LittleLong (linenos[i].fa.func);
|
|
linenos[i].line = LittleLong (linenos[i].line);
|
|
}
|
|
|
|
__auto_type local_defs = (pr_def_t*)((char*)debug + debug->locals);
|
|
for (i = 0; i < debug->num_locals; i++) {
|
|
byteswap_def (&local_defs[i]);
|
|
}
|
|
__auto_type debug_defs = (pr_def_t*)((char*)debug + debug->locals);
|
|
for (i = 0; i < debug->num_debug_defs; i++) {
|
|
byteswap_def (&debug_defs[i]);
|
|
}
|
|
|
|
PR_DebugSetSym (pr, debug);
|
|
return 1;
|
|
}
|
|
|
|
VISIBLE const char *
|
|
PR_Debug_GetBaseDirectory (progs_t *pr, const char *file)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
__auto_type cu = (compunit_t *) Hash_Find (res->compunits, file);
|
|
|
|
if (cu) {
|
|
return PR_GetString (pr, cu->unit->basedir);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
VISIBLE pr_auxfunction_t *
|
|
PR_Debug_AuxFunction (progs_t *pr, pr_uint_t func)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
if (!res->debug || func >= res->debug->num_auxfunctions) {
|
|
return 0;
|
|
}
|
|
return &res->auxfunctions[func];
|
|
}
|
|
|
|
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->functions.count) {
|
|
return 0;
|
|
}
|
|
return res->auxfunction_map[func];
|
|
}
|
|
|
|
VISIBLE pr_def_t *
|
|
PR_Debug_LocalDefs (progs_t *pr, pr_auxfunction_t *aux_function)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
if (!res->debug || !aux_function) {
|
|
return 0;
|
|
}
|
|
if (aux_function->local_defs > res->debug->num_locals) {
|
|
return 0;
|
|
}
|
|
return res->local_defs + aux_function->local_defs;
|
|
}
|
|
|
|
VISIBLE pr_lineno_t *
|
|
PR_Debug_Linenos (progs_t *pr, pr_auxfunction_t *aux_function,
|
|
pr_uint_t *num_linenos)
|
|
{
|
|
pr_uint_t i, count;
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
if (!res->debug) {
|
|
return 0;
|
|
}
|
|
if (!aux_function) {
|
|
*num_linenos = res->debug->num_linenos;
|
|
return res->linenos;
|
|
}
|
|
if (aux_function->line_info > res->debug->num_linenos) {
|
|
return 0;
|
|
}
|
|
//FIXME put lineno count in sym file
|
|
for (count = 1, i = aux_function->line_info + 1;
|
|
i < res->debug->num_linenos; i++, count++) {
|
|
if (!res->linenos[i].line) {
|
|
break;
|
|
}
|
|
}
|
|
*num_linenos = count;
|
|
return res->linenos + aux_function->line_info;
|
|
}
|
|
|
|
pr_auxfunction_t *
|
|
PR_Get_Lineno_Func (progs_t *pr, pr_lineno_t *lineno)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
while (lineno > res->linenos && lineno->line)
|
|
lineno--;
|
|
if (lineno->line)
|
|
return 0;
|
|
return &res->auxfunctions[lineno->fa.func];
|
|
}
|
|
|
|
pr_uint_t
|
|
PR_Get_Lineno_Addr (progs_t *pr, pr_lineno_t *lineno)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
pr_auxfunction_t *f;
|
|
|
|
if (lineno->line)
|
|
return lineno->fa.addr;
|
|
if (lineno->fa.func < res->debug->num_auxfunctions) {
|
|
f = &res->auxfunctions[lineno->fa.func];
|
|
return pr->pr_functions[f->function].first_statement;
|
|
}
|
|
// take a wild guess that only the line number is bogus and return
|
|
// the address anyway
|
|
return lineno->fa.addr;
|
|
}
|
|
|
|
pr_uint_t
|
|
PR_Get_Lineno_Line (progs_t *pr, pr_lineno_t *lineno)
|
|
{
|
|
if (lineno->line)
|
|
return lineno->line;
|
|
return 0;
|
|
}
|
|
|
|
pr_lineno_t *
|
|
PR_Find_Lineno (progs_t *pr, pr_uint_t addr)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
pr_uint_t i;
|
|
pr_lineno_t *lineno = 0;
|
|
|
|
if (!res->debug)
|
|
return 0;
|
|
if (!res->debug->num_linenos)
|
|
return 0;
|
|
for (i = res->debug->num_linenos; i > 0; i--) {
|
|
if (PR_Get_Lineno_Addr (pr, &res->linenos[i - 1]) <= addr) {
|
|
lineno = &res->linenos[i - 1];
|
|
break;
|
|
}
|
|
}
|
|
return lineno;
|
|
}
|
|
|
|
pr_uint_t
|
|
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->functions.count, sizeof (pr_func_t),
|
|
func_compare_search, res);
|
|
if (!f) {
|
|
return 0;
|
|
}
|
|
dfunction_t *func = &pr->pr_functions[*f];
|
|
if (func->first_statement <= 0
|
|
|| strcmp (file, PR_GetString (pr, func->file)) != 0) {
|
|
return 0;
|
|
}
|
|
pr_auxfunction_t *aux = res->auxfunction_map[*f];
|
|
if (!aux) {
|
|
return 0;
|
|
}
|
|
pr_uint_t addr = func->first_statement;
|
|
line -= aux->source_line;
|
|
|
|
//FIXME put lineno count in sym file
|
|
for (pr_uint_t i = aux->line_info + 1; i < res->debug->num_linenos; i++) {
|
|
if (!res->linenos[i].line) {
|
|
break;
|
|
}
|
|
if (res->linenos[i].line <= line) {
|
|
addr = res->linenos[i].fa.addr;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return addr;
|
|
}
|
|
|
|
const char *
|
|
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->functions.count)
|
|
return 0;
|
|
return PR_GetString(pr, pr->pr_functions[f->function].file);
|
|
}
|
|
|
|
const char *
|
|
PR_Get_Source_Line (progs_t *pr, pr_uint_t addr)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
const char *fname;
|
|
pr_uint_t line;
|
|
file_t *file;
|
|
pr_auxfunction_t *func;
|
|
pr_lineno_t *lineno;
|
|
|
|
lineno = PR_Find_Lineno (pr, addr);
|
|
if (!lineno || PR_Get_Lineno_Addr (pr, lineno) != addr)
|
|
return 0;
|
|
func = PR_Get_Lineno_Func (pr, lineno);
|
|
fname = PR_Get_Source_File (pr, lineno);
|
|
if (!func || !fname)
|
|
return 0;
|
|
line = PR_Get_Lineno_Line (pr, lineno);
|
|
line += func->source_line;
|
|
|
|
file = PR_Load_Source_File (pr, fname);
|
|
|
|
if (!file || !file->lines || !line || line > file->num_lines)
|
|
return dsprintf (res->dva, "%s:%u", fname, line);
|
|
|
|
return dsprintf (res->dva, "%s:%u:%.*s", fname, line,
|
|
(int)file->lines[line - 1].len,
|
|
file->lines[line - 1].text);
|
|
}
|
|
|
|
pr_def_t *
|
|
PR_Get_Param_Def (progs_t *pr, dfunction_t *func, unsigned param)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
pr_uint_t i;
|
|
pr_auxfunction_t *aux_func;
|
|
pr_def_t *ddef = 0;
|
|
int num_params;
|
|
int param_offs = 0;
|
|
|
|
if (!res->debug)
|
|
return 0;
|
|
if (!func)
|
|
return 0;
|
|
|
|
num_params = func->numparams;
|
|
if (num_params < 0) {
|
|
num_params = ~num_params; // one's compliment
|
|
param_offs = 1; // skip over @args def
|
|
}
|
|
if (param >= (unsigned) num_params)
|
|
return 0;
|
|
|
|
aux_func = res->auxfunction_map[func - pr->pr_functions];
|
|
if (!aux_func)
|
|
return 0;
|
|
|
|
for (i = 0; i < aux_func->num_locals; i++) {
|
|
ddef = &res->local_defs[aux_func->local_defs + param_offs + i];
|
|
if (!param--)
|
|
break;
|
|
}
|
|
return ddef;
|
|
}
|
|
|
|
static pr_auxfunction_t *
|
|
get_aux_function (progs_t *pr)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
dfunction_t *func;
|
|
if (!pr->pr_xfunction || !res->auxfunction_map)
|
|
return 0;
|
|
func = pr->pr_xfunction->descriptor;
|
|
return res->auxfunction_map[func - pr->pr_functions];
|
|
}
|
|
|
|
static qfot_type_t *
|
|
get_type (prdeb_resources_t *res, int typeptr)
|
|
{
|
|
progs_t *pr = res->pr;
|
|
|
|
if (!typeptr) {
|
|
return &res->void_type;
|
|
}
|
|
return &G_STRUCT (pr, qfot_type_t, typeptr);
|
|
}
|
|
|
|
pr_def_t *
|
|
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;
|
|
pr_ptr_t offs = *offset;
|
|
pr_def_t *def;
|
|
|
|
if (!pr->pr_xfunction)
|
|
return 0;
|
|
func = pr->pr_xfunction->descriptor;
|
|
if (!func)
|
|
return 0;
|
|
aux_func = res->auxfunction_map[func - pr->pr_functions];
|
|
if (!aux_func)
|
|
return 0;
|
|
|
|
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,
|
|
aux_func->num_locals, offs))) {
|
|
*offset = offs - def->ofs;
|
|
}
|
|
return def;
|
|
}
|
|
|
|
VISIBLE void
|
|
PR_DumpState (progs_t *pr)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
if (pr->pr_xfunction) {
|
|
if (pr_debug && res->debug) {
|
|
pr_lineno_t *lineno;
|
|
pr_auxfunction_t *func = 0;
|
|
dfunction_t *descriptor = pr->pr_xfunction->descriptor;
|
|
pr_int_t addr = pr->pr_xstatement;
|
|
|
|
lineno = PR_Find_Lineno (pr, addr);
|
|
if (lineno)
|
|
func = PR_Get_Lineno_Func (pr, lineno);
|
|
if (func && descriptor == pr->pr_functions + func->function)
|
|
addr = PR_Get_Lineno_Addr (pr, lineno);
|
|
else
|
|
addr = max (descriptor->first_statement, addr - 5);
|
|
|
|
while (addr != pr->pr_xstatement)
|
|
PR_PrintStatement (pr, pr->pr_statements + addr++, 3);
|
|
}
|
|
PR_PrintStatement (pr, pr->pr_statements + pr->pr_xstatement, 3);
|
|
}
|
|
PR_StackTrace (pr);
|
|
}
|
|
|
|
#define ISDENORM(x) ((x) && !((x) & 0x7f800000))
|
|
|
|
static void
|
|
value_string (pr_debug_data_t *data, qfot_type_t *type, pr_type_t *value)
|
|
{
|
|
switch (type->meta) {
|
|
case ty_handle:
|
|
case ty_basic:
|
|
switch (type->type) {
|
|
#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, "<?""?>");
|
|
}
|
|
break;
|
|
case ty_struct:
|
|
raw_type_view.struct_view (type, value, data);
|
|
break;
|
|
case ty_union:
|
|
raw_type_view.union_view (type, value, data);
|
|
break;
|
|
case ty_enum:
|
|
raw_type_view.enum_view (type, value, data);
|
|
break;
|
|
case ty_array:
|
|
raw_type_view.array_view (type, value, data);
|
|
break;
|
|
case ty_class:
|
|
raw_type_view.class_view (type, value, data);
|
|
break;
|
|
case ty_alias://XXX
|
|
type = &G_STRUCT (data->pr, qfot_type_t, type->alias.aux_type);
|
|
value_string (data, type, value);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static pr_def_t *
|
|
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 (pr_debug && 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) {
|
|
*ofs -= def->ofs;
|
|
}
|
|
}
|
|
return def;
|
|
}
|
|
|
|
static const char *
|
|
global_string (pr_debug_data_t *data, pr_ptr_t offset, qfot_type_t *type,
|
|
int contents)
|
|
{
|
|
progs_t *pr = data->pr;
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
dstring_t *dstr = data->dstr;
|
|
pr_def_t *def = NULL;
|
|
qfot_type_t dummy_type = { };
|
|
const char *name = 0;
|
|
pr_ptr_t offs = offset;
|
|
|
|
dstring_clearstr (dstr);
|
|
|
|
if (type && type->meta == ty_basic && type->type == ev_short) {
|
|
dsprintf (dstr, "%04x", (short) offset);
|
|
return dstr->str;
|
|
}
|
|
|
|
if (offset > pr->globals_size) {
|
|
dsprintf (dstr, "%08x out of bounds", offset);
|
|
return dstr->str;
|
|
}
|
|
|
|
def = pr_debug_find_def (pr, &offs);
|
|
if (!def || !PR_StringValid (pr, def->name)
|
|
|| !*(name = PR_GetString (pr, def->name))) {
|
|
dsprintf (dstr, "[$%x]", offset);
|
|
}
|
|
if (name) {
|
|
if (strequal (name, "IMMEDIATE") || strequal (name, ".imm")) {
|
|
contents = 1;
|
|
} else {
|
|
if (offs) {
|
|
dsprintf (dstr, "{%s + %u}", name, offs);
|
|
} else {
|
|
dsprintf (dstr, "%s", name);
|
|
}
|
|
}
|
|
}
|
|
if (contents) {
|
|
if (name) {
|
|
dstring_appendstr (dstr, "(");
|
|
}
|
|
if (!type) {
|
|
if (def) {
|
|
if (!def->type_encoding) {
|
|
dummy_type.type = def->type;
|
|
type = &dummy_type;
|
|
} else {
|
|
type = &G_STRUCT (pr, qfot_type_t, def->type_encoding);
|
|
}
|
|
} else {
|
|
type = &res->void_type;
|
|
}
|
|
}
|
|
value_string (data, type, pr->pr_globals + offset);
|
|
if (name) {
|
|
dstring_appendstr (dstr, ")");
|
|
}
|
|
}
|
|
return dstr->str;
|
|
}
|
|
|
|
const char *
|
|
PR_Debug_ValueString (progs_t *pr, pr_ptr_t offset, qfot_type_t *type,
|
|
dstring_t *dstr)
|
|
{
|
|
pr_debug_data_t data = {pr, dstr};
|
|
value_string (&data, type, pr->pr_globals + offset);
|
|
return dstr->str;
|
|
}
|
|
|
|
static void
|
|
pr_debug_void_view (qfot_type_t *type, pr_type_t *value, void *_data)
|
|
{
|
|
__auto_type data = (pr_debug_data_t *) _data;
|
|
dasprintf (data->dstr, "<void>");
|
|
}
|
|
|
|
static void
|
|
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;
|
|
pr_string_t string = PR_PTR (string, value);
|
|
if (PR_StringValid (data->pr, string)) {
|
|
const char *str = PR_GetString (data->pr, string);
|
|
|
|
dstring_appendstr (dstr, "\"");
|
|
while (*str) {
|
|
const char *s;
|
|
|
|
for (s = str; *s && !strchr ("\"\n\t", *s); s++) {
|
|
}
|
|
if (s != str) {
|
|
dstring_appendsubstr (dstr, str, s - str);
|
|
}
|
|
if (*s) {
|
|
switch (*s) {
|
|
case '\"':
|
|
dstring_appendstr (dstr, "\\\"");
|
|
break;
|
|
case '\n':
|
|
dstring_appendstr (dstr, "\\n");
|
|
break;
|
|
case '\t':
|
|
dstring_appendstr (dstr, "\\t");
|
|
break;
|
|
default:
|
|
dasprintf (dstr, "\\x%02x", *s & 0xff);
|
|
}
|
|
s++;
|
|
}
|
|
str = s;
|
|
}
|
|
dstring_appendstr (dstr, "\"");
|
|
} else {
|
|
dstring_appendstr (dstr, "*** invalid string offset ***");
|
|
}
|
|
}
|
|
|
|
static void
|
|
pr_debug_float_view (qfot_type_t *type, pr_type_t *value, void *_data)
|
|
{
|
|
__auto_type data = (pr_debug_data_t *) _data;
|
|
dstring_t *dstr = data->dstr;
|
|
|
|
if (data->pr->progs->version == PROG_ID_VERSION
|
|
&& ISDENORM (PR_PTR (int, value))
|
|
&& PR_PTR (uint, value) != 0x80000000) {
|
|
dasprintf (dstr, "<%08x>", PR_PTR (int, value));
|
|
} else {
|
|
dasprintf (dstr, "%.9g", PR_PTR (float, value));
|
|
}
|
|
}
|
|
|
|
static void
|
|
pr_debug_vector_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, "'%.9g %.9g %.9g'", VectorExpand (&PR_PTR (float, value)));
|
|
}
|
|
|
|
static void
|
|
pr_debug_entity_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;
|
|
|
|
if (pr->pr_edicts
|
|
&& PR_PTR (entity, value) < pr->max_edicts
|
|
&& !(PR_PTR (entity, value) % pr->pr_edict_size)) {
|
|
edict_t *edict = PROG_TO_EDICT (pr, PR_PTR (entity, value));
|
|
if (edict) {
|
|
dasprintf (dstr, "entity %d", NUM_FOR_BAD_EDICT (pr, edict));
|
|
return;
|
|
}
|
|
}
|
|
dasprintf (dstr, "entity [%x]", PR_PTR (entity, value));
|
|
}
|
|
|
|
static void
|
|
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, PR_PTR (int, value));
|
|
|
|
if (def) {
|
|
dasprintf (dstr, ".%s", PR_GetString (pr, def->name));
|
|
} else {
|
|
dasprintf (dstr, ".<$%04x>", PR_PTR (int, value));
|
|
}
|
|
}
|
|
|
|
static void
|
|
pr_debug_func_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;
|
|
|
|
if (PR_PTR (func, value) >= pr->progs->functions.count) {
|
|
dasprintf (dstr, "INVALID:%d", PR_PTR (func, value));
|
|
} else if (!PR_PTR (func, value)) {
|
|
dstring_appendstr (dstr, "NULL");
|
|
} else {
|
|
dfunction_t *f = pr->pr_functions + PR_PTR (func, value);
|
|
dasprintf (dstr, "%s()", PR_GetString (pr, f->name));
|
|
}
|
|
}
|
|
|
|
static void
|
|
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;
|
|
dstring_t *dstr = data->dstr;
|
|
pr_ptr_t offset = PR_PTR (int, value);
|
|
pr_ptr_t offs = offset;
|
|
pr_def_t *def = 0;
|
|
|
|
def = pr_debug_find_def (pr, &offs);
|
|
if (def && def->name) {
|
|
if (offs) {
|
|
dasprintf (dstr, "&%s + %u", PR_GetString (pr, def->name), offs);
|
|
} else {
|
|
dasprintf (dstr, "&%s", PR_GetString (pr, def->name));
|
|
}
|
|
} else {
|
|
dasprintf (dstr, "[$%x]", offset);
|
|
}
|
|
}
|
|
|
|
static void
|
|
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;
|
|
|
|
dasprintf (dstr, "'%.9g %.9g %.9g %.9g'", QuatExpand (&PR_PTR (float, value)));
|
|
}
|
|
|
|
static void
|
|
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", PR_PTR (int, value));
|
|
}
|
|
|
|
static void
|
|
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", PR_PTR (uint, value));
|
|
}
|
|
|
|
static void
|
|
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)PR_PTR (int, value));
|
|
}
|
|
|
|
static void
|
|
pr_debug_double_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, "%.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_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)PR_PTR (int, value));
|
|
}
|
|
|
|
static void
|
|
pr_dump_struct (qfot_type_t *type, pr_type_t *value, void *_data,
|
|
const char *struct_type)
|
|
{
|
|
__auto_type data = (pr_debug_data_t *) _data;
|
|
progs_t *pr = data->pr;
|
|
dstring_t *dstr = data->dstr;
|
|
qfot_struct_t *strct = &type->strct;
|
|
|
|
dstring_appendstr (dstr, "{");
|
|
for (int i = 0; i < strct->num_fields; i++) {
|
|
qfot_var_t *field = strct->fields + i;
|
|
qfot_type_t *val_type = &G_STRUCT (pr, qfot_type_t, field->type);
|
|
pr_type_t *val = value + field->offset;
|
|
dasprintf (dstr, "%s=", PR_GetString (pr, field->name));
|
|
value_string (data, val_type, val);
|
|
if (i < strct->num_fields - 1) {
|
|
dstring_appendstr (dstr, ", ");
|
|
}
|
|
}
|
|
dstring_appendstr (dstr, "}");
|
|
//dasprintf (dstr, "<%s>", struct_type);
|
|
}
|
|
static void
|
|
pr_debug_struct_view (qfot_type_t *type, pr_type_t *value, void *_data)
|
|
{
|
|
pr_dump_struct (type, value, _data, "struct");
|
|
}
|
|
|
|
static void
|
|
pr_debug_union_view (qfot_type_t *type, pr_type_t *value, void *_data)
|
|
{
|
|
pr_dump_struct (type, value, _data, "union");
|
|
}
|
|
|
|
static void
|
|
pr_debug_enum_view (qfot_type_t *type, pr_type_t *value, void *_data)
|
|
{
|
|
__auto_type data = (pr_debug_data_t *) _data;
|
|
dstring_t *dstr = data->dstr;
|
|
|
|
dstring_appendstr (dstr, "<enum>");
|
|
}
|
|
|
|
static void
|
|
pr_debug_array_view (qfot_type_t *type, pr_type_t *value, void *_data)
|
|
{
|
|
__auto_type data = (pr_debug_data_t *) _data;
|
|
dstring_t *dstr = data->dstr;
|
|
|
|
dstring_appendstr (dstr, "<array>");
|
|
}
|
|
|
|
static void
|
|
pr_debug_class_view (qfot_type_t *type, pr_type_t *value, void *_data)
|
|
{
|
|
__auto_type data = (pr_debug_data_t *) _data;
|
|
dstring_t *dstr = data->dstr;
|
|
|
|
dstring_appendstr (dstr, "<class>");
|
|
}
|
|
|
|
VISIBLE void
|
|
PR_Debug_Watch (progs_t *pr, const char *expr)
|
|
{
|
|
pr_def_t watch;
|
|
if (!expr) {
|
|
Sys_Printf ("watch <watchpoint expr>\n");
|
|
if (pr->watch) {
|
|
Sys_Printf (" watching [%d]\n",
|
|
(int) (intptr_t) (pr->watch - pr->pr_globals));
|
|
if (pr->wp_conditional)
|
|
Sys_Printf (" if new val == %d\n",
|
|
PR_PTR (int, &pr->wp_val));
|
|
} else { Sys_Printf (" none active\n");
|
|
}
|
|
return;
|
|
}
|
|
|
|
pr->watch = 0;
|
|
watch = parse_expression (pr, expr, 1);
|
|
if (watch.type != ev_invalid)
|
|
pr->watch = &pr->pr_globals[watch.ofs];
|
|
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_PTR (int, &pr->wp_val));
|
|
} else {
|
|
Sys_Printf ("watchpoint cleared\n");
|
|
}
|
|
}
|
|
|
|
VISIBLE void
|
|
PR_Debug_Print (progs_t *pr, const char *expr)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
pr_def_t print;
|
|
pr_debug_data_t data = {pr, res->dstr};
|
|
|
|
if (!expr) {
|
|
Sys_Printf ("print <print expr>\n");
|
|
return;
|
|
}
|
|
|
|
print = parse_expression (pr, expr, 0);
|
|
if (print.type_encoding) {
|
|
qfot_type_t *type = get_type (res, print.type_encoding);
|
|
const char *s = global_string (&data, print.ofs, type, 1);
|
|
Sys_Printf ("[%d] = %s\n", print.ofs, s);
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
int addr = s - pr->pr_statements;
|
|
int dump_code = contents & 2;
|
|
const char *fmt;
|
|
const char *mnemonic;
|
|
const char *width = "";
|
|
dfunction_t *call_func = 0;
|
|
pr_def_t *param_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);
|
|
|
|
data.pr = pr;
|
|
data.dstr = res->dstr;
|
|
|
|
if (pr_debug > 1)
|
|
dump_code = 1;
|
|
|
|
if (pr_debug && res->debug) {
|
|
const char *source_line = PR_Get_Source_Line (pr, addr);
|
|
|
|
if (source_line) {
|
|
dasprintf (res->line, "%s%s", source_line, dump_code ? "\n" : "");
|
|
if (!dump_code)
|
|
goto do_print;
|
|
}
|
|
if (!dump_code)
|
|
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) {
|
|
fmt = "%Ga, %Gb, %gc";
|
|
}
|
|
|
|
dasprintf (res->line, "%04x ", addr);
|
|
if (pr_debug > 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[1], op_width[1]),
|
|
print_raw_op (pr, s->c, PR_BASE_IND (s->op, C),
|
|
op_type[2], op_width[2]));
|
|
}
|
|
} else if (op_width[0] > 1 || op_width[1] > 1 || op_width[2] > 1) {
|
|
width = va (res->va, "{%d,%d,%d}", VectorExpand (op_width));
|
|
}
|
|
|
|
dasprintf (res->line, "%s%s ", mnemonic, width);
|
|
|
|
while (*fmt) {
|
|
if (*fmt == '%') {
|
|
if (fmt[1] == '%') {
|
|
dstring_appendsubstr (res->line, fmt + 1, 1);
|
|
fmt += 2;
|
|
} else {
|
|
const char *str;
|
|
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;
|
|
|
|
if (mode == 'P') {
|
|
opchar = fmt[3];
|
|
param_ind = fmt[2] - '0';
|
|
fmt++; // P has one extra item
|
|
if (param_ind >= PR_MAX_PARAMS)
|
|
goto err;
|
|
}
|
|
if (mode == 'M' || mode == 'm') {
|
|
if (!isxdigit ((byte) 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':
|
|
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;
|
|
}
|
|
switch (mode) {
|
|
case 'R':
|
|
optype = &res->void_type;
|
|
aux_func = get_aux_function (pr);
|
|
if (aux_func) {
|
|
optype = get_type (res, aux_func->return_type);
|
|
}
|
|
str = global_string (&data, opval, optype,
|
|
contents & 1);
|
|
break;
|
|
case 'F':
|
|
str = global_string (&data, opval, optype,
|
|
contents & 1);
|
|
func = G_FUNCTION (pr, opval);
|
|
if (func < pr->progs->functions.count) {
|
|
call_func = pr->pr_functions + func;
|
|
}
|
|
break;
|
|
case 'P':
|
|
param_def = PR_Get_Param_Def (pr, call_func, param_ind);
|
|
optype = &res->void_type;
|
|
if (param_def) {
|
|
optype = get_type (res, param_def->type_encoding);
|
|
}
|
|
str = global_string (&data, opval, optype,
|
|
contents & 1);
|
|
break;
|
|
case 'V':
|
|
opval += pr->pr_bases[opreg];
|
|
optype = &res->void_type;
|
|
str = global_string (&data, opval, optype,
|
|
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':
|
|
str = dsprintf (res->dva, "%d", (short) opval);
|
|
break;
|
|
case 'O':
|
|
str = dsprintf (res->dva, "%04x",
|
|
addr + (short) opval);
|
|
break;
|
|
case 'C':
|
|
str = dsprintf (res->dva, "%03o", opval);
|
|
break;
|
|
case 'E':
|
|
{
|
|
edict_t *ed = 0;
|
|
opval = G_ENTITY (pr, s->a);
|
|
param_ind = G_FIELD (pr, s->b);
|
|
if (param_ind < pr->progs->entityfields
|
|
&& opval > 0
|
|
&& opval < pr->pr_edict_area_size) {
|
|
ed = PROG_TO_EDICT (pr, opval);
|
|
opval = &E_fld(ed, param_ind) - pr->pr_globals;
|
|
}
|
|
if (!ed) {
|
|
str = "bad entity.field";
|
|
break;
|
|
}
|
|
str = global_string (&data, opval, optype,
|
|
contents & 1);
|
|
str = dsprintf (res->dva, "$%x $%x %s",
|
|
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;
|
|
}
|
|
dstring_appendstr (res->line, str);
|
|
fmt += 3;
|
|
continue;
|
|
err:
|
|
dstring_appendstr (res->line, fmt);
|
|
break;
|
|
}
|
|
} else {
|
|
dstring_appendsubstr (res->line, fmt++, 1);
|
|
}
|
|
}
|
|
do_print:
|
|
Sys_Printf ("%s\n", res->line->str);
|
|
}
|
|
|
|
static void
|
|
dump_frame (progs_t *pr, prstack_t *frame)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
dfunction_t *f = frame->func ? frame->func->descriptor : 0;
|
|
|
|
if (!f) {
|
|
Sys_Printf ("<NO FUNCTION>\n");
|
|
return;
|
|
}
|
|
if (pr_debug && res->debug) {
|
|
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_uint_t addr = PR_Get_Lineno_Addr (pr, lineno);
|
|
|
|
line += func->source_line;
|
|
if (addr == frame->staddr) {
|
|
Sys_Printf ("%12s:%u : %s: %x\n",
|
|
PR_GetString (pr, f->file),
|
|
line,
|
|
PR_GetString (pr, f->name),
|
|
frame->staddr);
|
|
} else {
|
|
Sys_Printf ("%12s:%u+%d : %s: %x\n",
|
|
PR_GetString (pr, f->file),
|
|
line, frame->staddr - addr,
|
|
PR_GetString (pr, f->name),
|
|
frame->staddr);
|
|
}
|
|
} else {
|
|
Sys_Printf ("%12s : %s: %x\n", PR_GetString (pr, f->file),
|
|
PR_GetString (pr, f->name), frame->staddr);
|
|
}
|
|
}
|
|
|
|
VISIBLE void
|
|
PR_StackTrace (progs_t *pr)
|
|
{
|
|
int i;
|
|
prstack_t top;
|
|
|
|
if (pr->pr_depth == 0) {
|
|
Sys_Printf ("<NO STACK>\n");
|
|
return;
|
|
}
|
|
|
|
top.staddr = pr->pr_xstatement;
|
|
top.func = pr->pr_xfunction;
|
|
dump_frame (pr, &top);
|
|
for (i = pr->pr_depth - 1; i >= 0; i--)
|
|
dump_frame (pr, pr->pr_stack + i);
|
|
}
|
|
|
|
VISIBLE void
|
|
PR_Profile (progs_t * pr)
|
|
{
|
|
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;
|
|
for (i = 0; i < pr->progs->functions.count; i++) {
|
|
bf = &pr->function_table[i];
|
|
if (bf->profile > max) {
|
|
max = bf->profile;
|
|
best = bf;
|
|
}
|
|
}
|
|
if (best) {
|
|
if (num < 10) {
|
|
f = pr->pr_functions + (best - pr->function_table);
|
|
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
|
|
print_field (progs_t *pr, edict_t *ed, pr_def_t *d)
|
|
{
|
|
prdeb_resources_t *res = pr->pr_debug_resources;
|
|
int l;
|
|
pr_type_t *v;
|
|
qfot_type_t dummy_type = { };
|
|
qfot_type_t *type;
|
|
pr_debug_data_t data = {pr, res->dstr};
|
|
const char *name;
|
|
|
|
name = PR_GetString (pr, d->name);
|
|
type = get_def_type (pr, d, &dummy_type);
|
|
v = &E_fld (ed, d->ofs);
|
|
|
|
l = 15 - strlen (name);
|
|
if (l < 1)
|
|
l = 1;
|
|
|
|
dstring_clearstr (res->dstr);
|
|
value_string (&data, type, v);
|
|
Sys_Printf ("%s%*s%s\n", name, l, "", res->dstr->str);
|
|
}
|
|
|
|
/*
|
|
ED_Print
|
|
|
|
For debugging
|
|
*/
|
|
VISIBLE void
|
|
ED_Print (progs_t *pr, edict_t *ed, const char *fieldname)
|
|
{
|
|
pr_uint_t i, j;
|
|
const char *name;
|
|
pr_def_t *d;
|
|
int l;
|
|
|
|
if (ed->free) {
|
|
Sys_Printf ("FREE\n");
|
|
return;
|
|
}
|
|
|
|
Sys_Printf ("\nEDICT %d:\n", NUM_FOR_BAD_EDICT (pr, ed));
|
|
|
|
if (fieldname) {
|
|
d = PR_FindField(pr, fieldname);
|
|
if (!d) {
|
|
Sys_Printf ("unknown field '%s'\n", fieldname);
|
|
} else {
|
|
print_field (pr, ed, d);
|
|
}
|
|
return;
|
|
}
|
|
for (i = 0; i < pr->progs->fielddefs.count; i++) {
|
|
d = &pr->pr_fielddefs[i];
|
|
if (!d->name) // null field def (probably 1st)
|
|
continue;
|
|
name = PR_GetString (pr, d->name);
|
|
l = strlen (name);
|
|
if (l >= 2 && name[l - 2] == '_' && strchr ("xyz", name[l - 1]))
|
|
continue; // skip _x, _y, _z vars
|
|
|
|
qfot_type_t dummy_type = { };
|
|
get_def_type (pr, d, &dummy_type);
|
|
for (j = 0; j < d->size; j++) {
|
|
if (E_INT (ed, d->ofs + j)) {
|
|
break;
|
|
}
|
|
}
|
|
if (j == d->size) {
|
|
continue;
|
|
}
|
|
|
|
print_field (pr, ed, d);
|
|
}
|
|
}
|
|
|
|
void
|
|
PR_Debug_Init (progs_t *pr)
|
|
{
|
|
prdeb_resources_t *res = calloc (1, sizeof (*res));
|
|
res->pr = pr;
|
|
res->string = dstring_newstr ();
|
|
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;
|
|
res->void_type.encoding = 0;
|
|
res->void_type.type = ev_void;
|
|
for (int i = 0; i < ev_type_count; i++ ) {
|
|
res->type_encodings[i] = &res->void_type;
|
|
}
|
|
res->file_hash = Hash_NewTable (509, file_get_key, file_free, 0,
|
|
pr->hashctx);
|
|
res->debug_syms = Hash_NewTable (509, def_get_key, 0, pr, pr->hashctx);
|
|
res->compunits = Hash_NewTable (509, compunit_get_key, 0, pr, pr->hashctx);
|
|
|
|
PR_Resources_Register (pr, "PR_Debug", res, pr_debug_clear,
|
|
pr_debug_destroy);
|
|
pr->pr_debug_resources = res;
|
|
}
|
|
|
|
static void
|
|
pr_debug_shutdown (void *data)
|
|
{
|
|
free (source_paths);
|
|
free (source_path_string);
|
|
}
|
|
|
|
void
|
|
PR_Debug_Init_Cvars (void)
|
|
{
|
|
Sys_RegisterShutdown (pr_debug_shutdown, 0);
|
|
Cvar_Register (&pr_debug_cvar, 0, 0);
|
|
Cvar_Register (&pr_source_path_cvar, source_path_f, 0);
|
|
}
|