xref: /dragonfly/sys/ddb/db_sym.c (revision 8d0b962d)
1 /*
2  * Mach Operating System
3  * Copyright (c) 1991,1990 Carnegie Mellon University
4  * All Rights Reserved.
5  *
6  * Permission to use, copy, modify and distribute this software and its
7  * documentation is hereby granted, provided that both the copyright
8  * notice and this permission notice appear in all copies of the
9  * software, derivative works or modified versions, and any portions
10  * thereof, and that both notices appear in supporting documentation.
11  *
12  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS
13  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
14  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
15  *
16  * Carnegie Mellon requests users of this software to return to
17  *
18  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
19  *  School of Computer Science
20  *  Carnegie Mellon University
21  *  Pittsburgh PA 15213-3890
22  *
23  * any improvements or extensions that they make and grant Carnegie the
24  * rights to redistribute these changes.
25  *
26  * $FreeBSD: src/sys/ddb/db_sym.c,v 1.32 1999/08/28 00:41:10 peter Exp $
27  */
28 
29 /*
30  * 	Author: David B. Golub, Carnegie Mellon University
31  *	Date:	7/90
32  */
33 #include <sys/param.h>
34 #include <sys/systm.h>
35 
36 #include <ddb/ddb.h>
37 #include <ddb/db_output.h>
38 #include <ddb/db_sym.h>
39 
40 /*
41  * Multiple symbol tables
42  */
43 #ifndef MAXNOSYMTABS
44 #define	MAXNOSYMTABS	3	/* mach, ux, emulator */
45 #endif
46 
47 static db_symtab_t	db_symtabs[MAXNOSYMTABS] = {{0,},};
48 static int db_nsymtab = 0;
49 
50 static db_symtab_t	*db_last_symtab; /* where last symbol was found */
51 
52 static c_db_sym_t	db_lookup ( const char *symstr);
53 static char		*db_qualify (c_db_sym_t sym, char *symtabname);
54 static boolean_t	db_symbol_is_ambiguous (c_db_sym_t sym);
55 static boolean_t	db_line_at_pc (c_db_sym_t, char **, int *,
56 				db_expr_t);
57 
58 /*
59  * Add symbol table, with given name, to list of symbol tables.
60  */
61 void
db_add_symbol_table(char * start,char * end,char * name,char * ref)62 db_add_symbol_table(char *start, char *end, char *name, char *ref)
63 {
64 	if (db_nsymtab >= MAXNOSYMTABS) {
65 		kprintf ("No slots left for %s symbol table", name);
66 		panic ("db_sym.c: db_add_symbol_table");
67 	}
68 
69 	db_symtabs[db_nsymtab].start = start;
70 	db_symtabs[db_nsymtab].end = end;
71 	db_symtabs[db_nsymtab].name = name;
72 	db_symtabs[db_nsymtab].private = ref;
73 	db_nsymtab++;
74 }
75 
76 /*
77  *  db_qualify("vm_map", "ux") returns "unix:vm_map".
78  *
79  *  Note: return value points to static data whose content is
80  *  overwritten by each call... but in practice this seems okay.
81  */
82 static char *
db_qualify(c_db_sym_t sym,char * symtabname)83 db_qualify(c_db_sym_t sym, char *symtabname)
84 {
85 	const char	*symname;
86 	static char     tmp[256];
87 
88 	db_symbol_values(sym, &symname, 0);
89 	ksnprintf(tmp, sizeof(tmp), "%s:%s", symtabname, symname);
90 	return tmp;
91 }
92 
93 
94 boolean_t
db_eqname(const char * src,const char * dst,int c)95 db_eqname(const char *src, const char *dst, int c)
96 {
97 	if (!strcmp(src, dst))
98 	    return (TRUE);
99 	if (src[0] == c)
100 	    return (!strcmp(src+1,dst));
101 	return (FALSE);
102 }
103 
104 boolean_t
db_value_of_name(const char * name,db_expr_t * valuep)105 db_value_of_name(const char *name, db_expr_t *valuep)
106 {
107 	c_db_sym_t	sym;
108 
109 	sym = db_lookup(name);
110 	if (sym == C_DB_SYM_NULL)
111 	    return (FALSE);
112 	db_symbol_values(sym, &name, valuep);
113 	return (TRUE);
114 }
115 
116 
117 /*
118  * Lookup a symbol.
119  * If the symbol has a qualifier (e.g., ux:vm_map),
120  * then only the specified symbol table will be searched;
121  * otherwise, all symbol tables will be searched.
122  */
123 static c_db_sym_t
db_lookup(const char * symstr)124 db_lookup(const char *symstr)
125 {
126 	c_db_sym_t sp;
127 	int i;
128 	int symtab_start = 0;
129 	int symtab_end = db_nsymtab;
130 	const char *cp;
131 
132 	/*
133 	 * Look for, remove, and remember any symbol table specifier.
134 	 */
135 	for (cp = symstr; *cp; cp++) {
136 		if (*cp == ':') {
137 			for (i = 0; i < db_nsymtab; i++) {
138 				int n = strlen(db_symtabs[i].name);
139 
140 				if (
141 				    n == (cp - symstr) &&
142 				    strncmp(symstr, db_symtabs[i].name, n) == 0
143 				) {
144 					symtab_start = i;
145 					symtab_end = i + 1;
146 					break;
147 				}
148 			}
149 			if (i == db_nsymtab) {
150 				db_error("invalid symbol table name");
151 			}
152 			symstr = cp+1;
153 		}
154 	}
155 
156 	/*
157 	 * Look in the specified set of symbol tables.
158 	 * Return on first match.
159 	 */
160 	for (i = symtab_start; i < symtab_end; i++) {
161 		sp = X_db_lookup(&db_symtabs[i], symstr);
162 		if (sp) {
163 			db_last_symtab = &db_symtabs[i];
164 			return sp;
165 		}
166 	}
167 	return 0;
168 }
169 
170 /*
171  * If TRUE, check across symbol tables for multiple occurrences
172  * of a name.  Might slow things down quite a bit.
173  */
174 static volatile boolean_t db_qualify_ambiguous_names = FALSE;
175 
176 /*
177  * Does this symbol name appear in more than one symbol table?
178  * Used by db_symbol_values to decide whether to qualify a symbol.
179  */
180 static boolean_t
db_symbol_is_ambiguous(c_db_sym_t sym)181 db_symbol_is_ambiguous(c_db_sym_t sym)
182 {
183 	const char	*sym_name;
184 	int	i;
185 
186 	boolean_t	found_once = FALSE;
187 
188 	if (!db_qualify_ambiguous_names)
189 		return FALSE;
190 
191 	db_symbol_values(sym, &sym_name, 0);
192 	for (i = 0; i < db_nsymtab; i++) {
193 		if (X_db_lookup(&db_symtabs[i], sym_name)) {
194 			if (found_once)
195 				return TRUE;
196 			found_once = TRUE;
197 		}
198 	}
199 	return FALSE;
200 }
201 
202 /*
203  * Find the closest symbol to val, and return its name
204  * and the difference between val and the symbol found.
205  */
206 c_db_sym_t
db_search_symbol(db_addr_t val,db_strategy_t strategy,db_expr_t * offp)207 db_search_symbol(db_addr_t val, db_strategy_t strategy, db_expr_t *offp)
208 {
209 
210 	unsigned int	diff;
211 	size_t		newdiff;
212 	int	i;
213 	c_db_sym_t	ret = C_DB_SYM_NULL, sym;
214 
215 	newdiff = diff = ~0;
216 	db_last_symtab = NULL;
217 	for (i = 0; i < db_nsymtab; i++) {
218 	    sym = X_db_search_symbol(&db_symtabs[i], val, strategy, &newdiff);
219 	    if (newdiff < diff) {
220 		db_last_symtab = &db_symtabs[i];
221 		diff = newdiff;
222 		ret = sym;
223 	    }
224 	}
225 	*offp = diff;
226 	return ret;
227 }
228 
229 /*
230  * Return name and value of a symbol
231  */
232 void
db_symbol_values(c_db_sym_t sym,const char ** namep,db_expr_t * valuep)233 db_symbol_values(c_db_sym_t sym, const char **namep, db_expr_t *valuep)
234 {
235 	db_expr_t	value;
236 
237 	if (sym == DB_SYM_NULL) {
238 		*namep = NULL;
239 		return;
240 	}
241 
242 	X_db_symbol_values(db_last_symtab, sym, namep, &value);
243 
244 	if (db_symbol_is_ambiguous(sym))
245 		*namep = db_qualify(sym, db_last_symtab->name);
246 	if (valuep)
247 		*valuep = value;
248 }
249 
250 
251 /*
252  * Print a the closest symbol to value
253  *
254  * After matching the symbol according to the given strategy
255  * we print it in the name+offset format, provided the symbol's
256  * value is close enough (eg smaller than db_maxoff).
257  * We also attempt to print [filename:linenum] when applicable
258  * (eg for procedure names).
259  *
260  * If we could not find a reasonable name+offset representation,
261  * then we just print the value in hex.  Small values might get
262  * bogus symbol associations, e.g. 3 might get some absolute
263  * value like _INCLUDE_VERSION or something, therefore we do
264  * not accept symbols whose value is "small" (and use plain hex).
265  */
266 
267 db_expr_t	db_maxoff = 0x100000;
268 
269 void
db_printsym(db_expr_t off,db_strategy_t strategy)270 db_printsym(db_expr_t off, db_strategy_t strategy)
271 {
272 	db_expr_t	d;
273 	char 		*filename;
274 	const char	*name;
275 	db_expr_t	value;
276 	int 		linenum;
277 	c_db_sym_t	cursym;
278 	char		tbuf[24];
279 
280 	cursym = db_search_symbol(off, strategy, &d);
281 	db_symbol_values(cursym, &name, &value);
282 	if (name == NULL)
283 		value = off;
284 	if (value >= DB_SMALL_VALUE_MIN && value <= DB_SMALL_VALUE_MAX) {
285 		db_format_radix(tbuf, 24, (long)off, TRUE);
286 		db_printf("%s", tbuf);
287 		return;
288 	}
289 	if (name == NULL || d >= (unsigned long)db_maxoff) {
290 		db_format_radix(tbuf, 24, (unsigned long)off, TRUE);
291 		db_printf("%s", tbuf);
292 		return;
293 	}
294 	db_printf("%s", name);
295 	if (d) {
296 		db_format_radix(tbuf, 24, (long)d, TRUE);
297 		db_printf("+%s", tbuf);
298 	}
299 	if (strategy == DB_STGY_PROC) {
300 		if (db_line_at_pc(cursym, &filename, &linenum, off))
301 			db_printf(" [%s:%d]", filename, linenum);
302 	}
303 }
304 
305 static boolean_t
db_line_at_pc(c_db_sym_t sym,char ** filename,int * linenum,db_expr_t pc)306 db_line_at_pc(c_db_sym_t sym, char **filename, int *linenum, db_expr_t pc)
307 {
308 	return X_db_line_at_pc( db_last_symtab, sym, filename, linenum, pc);
309 }
310 
311 int
db_sym_numargs(c_db_sym_t sym,int * nargp,char ** argnames)312 db_sym_numargs(c_db_sym_t sym, int *nargp, char **argnames)
313 {
314 	return X_db_sym_numargs(db_last_symtab, sym, nargp, argnames);
315 }
316