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 *);