This diff removes the "symbol table" argument of the functions dealing
with symbols. While here keep the definition of ``db_symtab'' private
because we only have one global symbol table.
ok?
Index: ddb/db_elf.c
===================================================================
RCS file: /cvs/src/sys/ddb/db_elf.c,v
retrieving revision 1.16
diff -u -p -r1.16 db_elf.c
--- ddb/db_elf.c 27 Jan 2016 10:37:12 -0000 1.16
+++ ddb/db_elf.c 26 Feb 2016 15:28:20 -0000
@@ -45,6 +45,16 @@
#include <sys/exec_elf.h>
+
+typedef struct {
+ const char *name; /* symtab name */
+ char *start; /* symtab location */
+ char *end;
+ char *private; /* optional machdep pointer */
+} db_symtab_t;
+
+db_symtab_t db_symtab;
+
static char *db_elf_find_strtab(db_symtab_t *);
static char *db_elf_find_linetab(db_symtab_t *, size_t *);
@@ -171,15 +181,16 @@ db_elf_sym_init(int symsize, void *symta
/*
* Link the symbol table into the debugger.
*/
- if (db_add_symbol_table((char *)symtab_start,
- (char *)symtab_end, name, (char *)symtab) != -1) {
- db_printf("[ using %lu bytes of %s ELF symbol table ]\n",
- (u_long)roundup(((char *)esymtab - (char *)symtab),
- sizeof(u_long)), name);
- return (TRUE);
- }
+ db_symtab.start = (char *)symtab_start;
+ db_symtab.end = (char *)symtab_end;
+ db_symtab.name = name;
+ db_symtab.private = (char *)symtab;
+
+ db_printf("[ using %lu bytes of %s ELF symbol table ]\n",
+ (u_long)roundup(((char *)esymtab - (char *)symtab), sizeof(u_long)),
+ name);
- return (FALSE);
+ return (TRUE);
badheader:
db_printf("[ %s ELF symbol table not valid: %s ]\n", name, errstr);
@@ -237,11 +248,15 @@ db_elf_find_linetab(db_symtab_t *stab, s
* Lookup the symbol with the given name.
*/
db_sym_t
-db_elf_sym_lookup(db_symtab_t *stab, char *symstr)
+db_elf_sym_lookup(char *symstr)
{
+ db_symtab_t *stab = &db_symtab;
Elf_Sym *symp, *symtab_start, *symtab_end;
char *strtab;
+ if (stab->private == NULL)
+ return ((db_sym_t)0);
+
symtab_start = STAB_TO_SYMSTART(stab);
symtab_end = STAB_TO_SYMEND(stab);
@@ -263,14 +278,18 @@ db_elf_sym_lookup(db_symtab_t *stab, cha
* provided threshold).
*/
db_sym_t
-db_elf_sym_search(db_symtab_t *symtab, db_addr_t off, db_strategy_t strategy,
+db_elf_sym_search(db_addr_t off, db_strategy_t strategy,
db_expr_t *diffp)
{
+ db_symtab_t *stab = &db_symtab;
Elf_Sym *rsymp, *symp, *symtab_start, *symtab_end;
db_expr_t diff = *diffp;
- symtab_start = STAB_TO_SYMSTART(symtab);
- symtab_end = STAB_TO_SYMEND(symtab);
+ if (stab->private == NULL)
+ return ((db_sym_t)0);
+
+ symtab_start = STAB_TO_SYMSTART(stab);
+ symtab_end = STAB_TO_SYMEND(stab);
rsymp = NULL;
@@ -326,14 +345,18 @@ db_elf_sym_search(db_symtab_t *symtab, d
* Return the name and value for a symbol.
*/
void
-db_elf_sym_values(db_symtab_t *symtab, db_sym_t sym, char **namep,
+db_elf_sym_values(db_sym_t sym, char **namep,
db_expr_t *valuep)
{
+ db_symtab_t *stab = &db_symtab;
Elf_Sym *symp = (Elf_Sym *)sym;
char *strtab;
+ if (stab->private == NULL)
+ return;
+
if (namep) {
- strtab = db_elf_find_strtab(symtab);
+ strtab = db_elf_find_strtab(stab);
if (strtab == NULL)
*namep = NULL;
else
@@ -349,14 +372,18 @@ db_elf_sym_values(db_symtab_t *symtab, d
* if we can find the appropriate debugging symbol.
*/
boolean_t
-db_elf_line_at_pc(db_symtab_t *symtab, db_sym_t cursym, char **filename,
+db_elf_line_at_pc(db_sym_t cursym, char **filename,
int *linenum, db_expr_t off)
{
+ db_symtab_t *stab = &db_symtab;
static char path[PATH_MAX];
const char *linetab, *dirname, *basename;
size_t linetab_size;
- linetab = db_elf_find_linetab(symtab, &linetab_size);
+ if (stab->private == NULL)
+ return (FALSE);
+
+ linetab = db_elf_find_linetab(stab, &linetab_size);
if (linetab == NULL)
return (FALSE);
@@ -373,12 +400,16 @@ db_elf_line_at_pc(db_symtab_t *symtab, d
}
void
-db_elf_sym_forall(db_symtab_t *stab, db_forall_func_t db_forall_func, void
*arg)
+db_elf_sym_forall(db_forall_func_t db_forall_func, void *arg)
{
+ db_symtab_t *stab = &db_symtab;
char *strtab;
static char suffix[2];
Elf_Sym *symp, *symtab_start, *symtab_end;
+ if (stab->private == NULL)
+ return;
+
symtab_start = STAB_TO_SYMSTART(stab);
symtab_end = STAB_TO_SYMEND(stab);
@@ -405,8 +436,7 @@ db_elf_sym_forall(db_symtab_t *stab, db_
default:
suffix[0] = '\0';
}
- (*db_forall_func)(stab, (db_sym_t)symp,
+ (*db_forall_func)((db_sym_t)symp,
strtab + symp->st_name, suffix, 0, arg);
}
- return;
}
Index: ddb/db_hangman.c
===================================================================
RCS file: /cvs/src/sys/ddb/db_hangman.c,v
retrieving revision 1.34
diff -u -p -r1.34 db_hangman.c
--- ddb/db_hangman.c 26 Feb 2016 15:27:53 -0000 1.34
+++ ddb/db_hangman.c 26 Feb 2016 15:28:21 -0000
@@ -72,12 +72,10 @@ struct db_hang_forall_arg {
/*
* Horrible abuse of the forall function, but we're not in a hurry.
*/
-static void db_hang_forall(db_symtab_t *, db_sym_t, char *, char *, int,
- void *);
+static void db_hang_forall(db_sym_t, char *, char *, int, void *);
static void
-db_hang_forall(db_symtab_t *stab, db_sym_t sym, char *name, char *suff, int
pre,
- void *varg)
+db_hang_forall(db_sym_t sym, char *name, char *suff, int pre, void *varg)
{
struct db_hang_forall_arg *arg = (struct db_hang_forall_arg *)varg;
@@ -88,30 +86,21 @@ db_hang_forall(db_symtab_t *stab, db_sym
static __inline char *
db_randomsym(size_t *lenp)
{
- extern db_symtab_t db_symtab;
- db_symtab_t *stab = &db_symtab;
int nsyms;
char *p, *q;
struct db_hang_forall_arg dfa;
- if (stab->start == 0)
- return (NULL);
-
dfa.cnt = 0;
- db_elf_sym_forall(stab, db_hang_forall, &dfa);
+ db_elf_sym_forall(db_hang_forall, &dfa);
nsyms = -dfa.cnt;
if (nsyms == 0)
return (NULL);
dfa.cnt = arc4random_uniform(nsyms);
- db_elf_sym_forall(stab, db_hang_forall, &dfa);
-
- q = db_qualify(dfa.sym, stab->name);
+ db_elf_sym_forall(db_hang_forall, &dfa);
- /* don't show symtab name */
- while (*q++ != ':')
- ;
+ db_symbol_values(dfa.sym, &q, 0);
/* strlen(q) && ignoring underscores and colons */
for ((*lenp) = 0, p = q; *p; p++)
Index: ddb/db_sym.c
===================================================================
RCS file: /cvs/src/sys/ddb/db_sym.c,v
retrieving revision 1.45
diff -u -p -r1.45 db_sym.c
--- ddb/db_sym.c 26 Feb 2016 15:27:53 -0000 1.45
+++ ddb/db_sym.c 26 Feb 2016 15:28:21 -0000
@@ -48,8 +48,6 @@
#define MAXNOSYMTABS MAXLKMS+1 /* Room for kernel + LKM's */
#endif
-db_symtab_t db_symtab;
-
extern char end[];
/*
@@ -94,56 +92,6 @@ ddb_init(void)
printf("[ no symbol table formats found ]\n");
}
-/*
- * Add symbol table, with given name, to list of symbol tables.
- */
-int
-db_add_symbol_table(char *start, char *end, const char *name, char *ref)
-{
- db_symtab.start = start;
- db_symtab.end = end;
- db_symtab.name = name;
- db_symtab.private = ref;
-
- return 0;
-}
-
-/*
- * Delete a symbol table. Caller is responsible for freeing storage.
- */
-void
-db_del_symbol_table(char *name)
-{
- db_symtab.start = 0;
- db_symtab.end = 0;
- db_symtab.name = 0;
- db_symtab.private = 0;
-}
-
-/*
- * db_qualify("vm_map", "bsd") returns "bsd:vm_map".
- *
- * Note: return value points to static data whose content is
- * overwritten by each call... but in practice this seems okay.
- */
-char *
-db_qualify(db_sym_t sym, const char *symtabname)
-{
- char *symname;
- static char tmp[256];
- char *s;
-
- db_symbol_values(sym, &symname, 0);
- s = tmp;
- while ((*s++ = *symtabname++) != '\0')
- ;
- s[-1] = ':';
- while ((*s++ = *symname++) != '\0')
- ;
- return tmp;
-}
-
-
boolean_t
db_eqname(char *src, char *dst, int c)
{
@@ -173,7 +121,7 @@ db_value_of_name(char *name, db_expr_t *
db_sym_t
db_lookup(char *symstr)
{
- return db_elf_sym_lookup(&db_symtab, symstr);
+ return db_elf_sym_lookup(symstr);
}
/*
@@ -188,7 +136,7 @@ db_search_symbol(db_addr_t val, db_strat
db_sym_t ret = DB_SYM_NULL, sym;
newdiff = diff = ~0;
- sym = db_elf_sym_search(&db_symtab, val, strategy, &newdiff);
+ sym = db_elf_sym_search(val, strategy, &newdiff);
if (newdiff < diff) {
diff = newdiff;
ret = sym;
@@ -210,7 +158,7 @@ db_symbol_values(db_sym_t sym, char **na
return;
}
- db_elf_sym_values(&db_symtab, sym, namep, &value);
+ db_elf_sym_values(sym, namep, &value);
if (valuep)
*valuep = value;
@@ -261,8 +209,8 @@ db_printsym(db_expr_t off, db_strategy_t
d, DB_FORMAT_R, 1, 0));
}
if (strategy != DB_STGY_PROC) {
- if (db_elf_line_at_pc(&db_symtab, cursym,
- &filename, &linenum, off))
+ if (db_elf_line_at_pc(cursym, &filename,
+ &linenum, off))
(*pr)(" [%s:%d]", filename, linenum);
}
return;
Index: ddb/db_sym.h
===================================================================
RCS file: /cvs/src/sys/ddb/db_sym.h,v
retrieving revision 1.21
diff -u -p -r1.21 db_sym.h
--- ddb/db_sym.h 12 Feb 2016 10:58:41 -0000 1.21
+++ ddb/db_sym.h 26 Feb 2016 15:28:21 -0000
@@ -30,18 +30,6 @@
*/
/*
- * This module can handle multiple symbol tables
- */
-typedef struct {
- const char *name; /* symtab name */
- char *start; /* symtab location */
- char *end;
- char *private; /* optional machdep pointer */
-} db_symtab_t;
-
-extern db_symtab_t *db_last_symtab; /* where last symbol was found */
-
-/*
* Symbol representation is specific to the symtab style:
* BSD compilers use dbx' nlist, other compilers might use
* a different one
@@ -72,17 +60,9 @@ typedef int db_strategy_t; /* search st
* the type, prefix an initial ignorable function prefix (e.g. "_"
* in a.out), and arg an opaque argument to be passed in.
*/
-typedef void (db_forall_func_t)(db_symtab_t *, db_sym_t, char *, char *, int,
void *);
+typedef void (db_forall_func_t)(db_sym_t, char *, char *, int, void *);
extern unsigned int db_maxoff; /* like gdb's "max-symbolic-offset" */
-/*
- * Functions exported by the symtable module
- */
-int db_add_symbol_table(char *, char *, const char *, char *);
- /* extend the list of symbol tables */
-
-void db_del_symbol_table(char *);
- /* remove a symbol table from list */
boolean_t db_eqname(char *, char *, int);
/* strcmp, modulo leading char */
@@ -111,11 +91,9 @@ void db_printsym(db_expr_t, db_strategy_
#define db_sym_numargs(sym, nargp, argnames) (FALSE)
-char *db_qualify(db_sym_t, const char *);
-
boolean_t db_elf_sym_init(int, void *, void *, const char *);
-db_sym_t db_elf_sym_lookup(db_symtab_t *, char *);
-void db_elf_sym_values(db_symtab_t *, db_sym_t, char **, db_expr_t *);
-db_sym_t db_elf_sym_search(db_symtab_t *, db_addr_t, db_strategy_t, db_expr_t
*);
-boolean_t db_elf_line_at_pc(db_symtab_t *, db_sym_t, char **, int *,
db_expr_t);
-void db_elf_sym_forall(db_symtab_t *, db_forall_func_t db_forall_func, void *);
+db_sym_t db_elf_sym_lookup(char *);
+void db_elf_sym_values(db_sym_t, char **, db_expr_t *);
+db_sym_t db_elf_sym_search(db_addr_t, db_strategy_t, db_expr_t *);
+boolean_t db_elf_line_at_pc(db_sym_t, char **, int *, db_expr_t);
+void db_elf_sym_forall(db_forall_func_t db_forall_func, void *);
