![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to db_sym.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / ddb|
Return to db_sym.c CVS log | Up to [Net/2] / Net2 / ddb |
1.1 root 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 [email protected]
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: /*
27: * HISTORY
28: * $Log: db_sym.c,v $
29: * Revision 1.1 1992/03/25 21:45:27 pace
30: * Initial revision
31: *
32: * Revision 2.5 91/02/05 17:07:07 mrt
33: * Changed to new Mach copyright
34: * [91/01/31 16:19:17 mrt]
35: *
36: * Revision 2.4 90/10/25 14:44:05 rwd
37: * Changed db_printsym to print unsigned.
38: * [90/10/19 rpd]
39: *
40: * Revision 2.3 90/09/09 23:19:56 rpd
41: * Avoid totally incorrect guesses of symbol names for small values.
42: * [90/08/30 17:39:48 af]
43: *
44: * Revision 2.2 90/08/27 21:52:18 dbg
45: * Removed nlist.h. Fixed some type declarations.
46: * Qualifier character is ':'.
47: * [90/08/20 dbg]
48: * Modularized symtab info into a new db_symtab_t type.
49: * Modified db_add_symbol_table and others accordingly.
50: * Defined db_sym_t, a new (opaque) type used to represent
51: * symbols. This should support all sort of future symtable
52: * formats. Functions like db_qualify take a db_sym_t now.
53: * New db_symbol_values() function to explode the content
54: * of a db_sym_t.
55: * db_search_symbol() replaces db_find_sym_and_offset(), which is
56: * now a macro defined in our (new) header file. This new
57: * function accepts more restrictive searches, which are
58: * entirely delegated to the symtab-specific code.
59: * Accordingly, db_printsym() accepts a strategy parameter.
60: * New db_line_at_pc() function.
61: * Renamed misleading db_eqsym into db_eqname.
62: * [90/08/20 10:47:06 af]
63: *
64: * Created.
65: * [90/07/25 dbg]
66: *
67: * Revision 2.1 90/07/26 16:43:52 dbg
68: * Created.
69: *
70: */
71: /*
72: * Author: David B. Golub, Carnegie Mellon University
73: * Date: 7/90
74: */
75: #include "param.h"
76: #include "proc.h"
77: #include <machine/db_machdep.h>
78: #include <ddb/db_sym.h>
79:
80: /*
81: * We import from the symbol-table dependent routines:
82: */
83: extern db_sym_t X_db_lookup();
84: extern db_sym_t X_db_search_symbol();
85: extern boolean_t X_db_line_at_pc();
86: extern void X_db_symbol_values();
87:
88: /*
89: * Multiple symbol tables
90: */
91: #define MAXNOSYMTABS 3 /* mach, ux, emulator */
92:
93: db_symtab_t db_symtabs[MAXNOSYMTABS] = {{0,},};
94: int db_nsymtab = 0;
95:
96: db_symtab_t *db_last_symtab;
97:
98: db_sym_t db_lookup(); /* forward */
99:
100: /*
101: * Add symbol table, with given name, to list of symbol tables.
102: */
103: void
104: db_add_symbol_table(start, end, name, ref)
105: char *start;
106: char *end;
107: char *name;
108: char *ref;
109: {
110: if (db_nsymtab >= MAXNOSYMTABS) {
111: printf ("No slots left for %s symbol table", name);
112: panic ("db_sym.c: db_add_symbol_table");
113: }
114:
115: db_symtabs[db_nsymtab].start = start;
116: db_symtabs[db_nsymtab].end = end;
117: db_symtabs[db_nsymtab].name = name;
118: db_symtabs[db_nsymtab].private = ref;
119: db_nsymtab++;
120: }
121:
122: /*
123: * db_qualify("vm_map", "ux") returns "unix:vm_map".
124: *
125: * Note: return value points to static data whose content is
126: * overwritten by each call... but in practice this seems okay.
127: */
128: static char *
129: db_qualify(sym, symtabname)
130: db_sym_t sym;
131: register char *symtabname;
132: {
133: char *symname;
134: static char tmp[256];
135: register char *s;
136:
137: db_symbol_values(sym, &symname, 0);
138: s = tmp;
139: while (*s++ = *symtabname++) {
140: }
141: s[-1] = ':';
142: while (*s++ = *symname++) {
143: }
144: return tmp;
145: }
146:
147:
148: boolean_t
149: db_eqname(src, dst, c)
150: char *src;
151: char *dst;
152: char c;
153: {
154: if (!strcmp(src, dst))
155: return (TRUE);
156: if (src[0] == c)
157: return (!strcmp(src+1,dst));
158: return (FALSE);
159: }
160:
161: boolean_t
162: db_value_of_name(name, valuep)
163: char *name;
164: db_expr_t *valuep;
165: {
166: db_sym_t sym;
167:
168: sym = db_lookup(name);
169: if (sym == DB_SYM_NULL)
170: return (FALSE);
171: db_symbol_values(sym, &name, valuep);
172: return (TRUE);
173: }
174:
175:
176: /*
177: * Lookup a symbol.
178: * If the symbol has a qualifier (e.g., ux:vm_map),
179: * then only the specified symbol table will be searched;
180: * otherwise, all symbol tables will be searched.
181: */
182: db_sym_t
183: db_lookup(symstr)
184: char *symstr;
185: {
186: db_sym_t sp;
187: register int i;
188: int symtab_start = 0;
189: int symtab_end = db_nsymtab;
190: register char *cp;
191:
192: /*
193: * Look for, remove, and remember any symbol table specifier.
194: */
195: for (cp = symstr; *cp; cp++) {
196: if (*cp == ':') {
197: *cp = '\0';
198: for (i = 0; i < db_nsymtab; i++) {
199: if (! strcmp(symstr, db_symtabs[i].name)) {
200: symtab_start = i;
201: symtab_end = i + 1;
202: break;
203: }
204: }
205: *cp = ':';
206: if (i == db_nsymtab) {
207: db_error("invalid symbol table name");
208: }
209: symstr = cp+1;
210: }
211: }
212:
213: /*
214: * Look in the specified set of symbol tables.
215: * Return on first match.
216: */
217: for (i = symtab_start; i < symtab_end; i++) {
218: if (sp = X_db_lookup(&db_symtabs[i], symstr)) {
219: db_last_symtab = &db_symtabs[i];
220: return sp;
221: }
222: }
223: return 0;
224: }
225:
226: /*
227: * Does this symbol name appear in more than one symbol table?
228: * Used by db_symbol_values to decide whether to qualify a symbol.
229: */
230: boolean_t db_qualify_ambiguous_names = FALSE;
231:
232: boolean_t
233: db_symbol_is_ambiguous(sym)
234: db_sym_t sym;
235: {
236: char *sym_name;
237: register int i;
238: register
239: boolean_t found_once = FALSE;
240:
241: if (!db_qualify_ambiguous_names)
242: return FALSE;
243:
244: db_symbol_values(sym, &sym_name, 0);
245: for (i = 0; i < db_nsymtab; i++) {
246: if (X_db_lookup(&db_symtabs[i], sym_name)) {
247: if (found_once)
248: return TRUE;
249: found_once = TRUE;
250: }
251: }
252: return FALSE;
253: }
254:
255: /*
256: * Find the closest symbol to val, and return its name
257: * and the difference between val and the symbol found.
258: */
259: db_sym_t
260: db_search_symbol( val, strategy, offp)
261: register db_addr_t val;
262: db_strategy_t strategy;
263: db_expr_t *offp;
264: {
265: register
266: unsigned int diff;
267: unsigned int newdiff;
268: register int i;
269: db_sym_t ret = DB_SYM_NULL, sym;
270:
271: newdiff = diff = ~0;
272: db_last_symtab = 0;
273: for (i = 0; i < db_nsymtab; i++) {
274: sym = X_db_search_symbol(&db_symtabs[i], val, strategy, &newdiff);
275: if (newdiff < diff) {
276: db_last_symtab = &db_symtabs[i];
277: diff = newdiff;
278: ret = sym;
279: }
280: }
281: *offp = diff;
282: return ret;
283: }
284:
285: /*
286: * Return name and value of a symbol
287: */
288: void
289: db_symbol_values(sym, namep, valuep)
290: db_sym_t sym;
291: char **namep;
292: db_expr_t *valuep;
293: {
294: db_expr_t value;
295:
296: if (sym == DB_SYM_NULL) {
297: *namep = 0;
298: return;
299: }
300:
301: X_db_symbol_values(sym, namep, &value);
302:
303: if (db_symbol_is_ambiguous(sym))
304: *namep = db_qualify(sym, db_last_symtab->name);
305: if (valuep)
306: *valuep = value;
307: }
308:
309:
310: /*
311: * Print a the closest symbol to value
312: *
313: * After matching the symbol according to the given strategy
314: * we print it in the name+offset format, provided the symbol's
315: * value is close enough (eg smaller than db_maxoff).
316: * We also attempt to print [filename:linenum] when applicable
317: * (eg for procedure names).
318: *
319: * If we could not find a reasonable name+offset representation,
320: * then we just print the value in hex. Small values might get
321: * bogus symbol associations, e.g. 3 might get some absolute
322: * value like _INCLUDE_VERSION or something, therefore we do
323: * not accept symbols whose value is zero (and use plain hex).
324: */
325:
326: unsigned int db_maxoff = 0x10000000;
327:
328: void
329: db_printsym(off, strategy)
330: db_expr_t off;
331: db_strategy_t strategy;
332: {
333: db_expr_t d;
334: char *filename;
335: char *name;
336: db_expr_t value;
337: int linenum;
338: db_sym_t cursym;
339:
340: cursym = db_search_symbol(off, strategy, &d);
341: db_symbol_values(cursym, &name, &value);
342: if (name == 0 || d >= db_maxoff || value == 0) {
343: db_printf("%#n", off);
344: return;
345: }
346: db_printf("%s", name);
347: if (d)
348: db_printf("+%#r", d);
349: if (strategy == DB_STGY_PROC) {
350: if (db_line_at_pc(cursym, &filename, &linenum, off))
351: db_printf(" [%s:%d]", filename, linenum);
352: }
353: }
354:
355:
356: boolean_t
357: db_line_at_pc( sym, filename, linenum, pc)
358: {
359: return X_db_line_at_pc( db_last_symtab, sym, filename, linenum, pc);
360: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.