![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to db_aout.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / ddb|
Return to db_aout.c CVS log | Up to [GnuMach] / Gnu-Mach / 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 "AS IS"
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 Mellon
24: * the rights to redistribute these changes.
25: */
26: /*
27: * Author: David B. Golub, Carnegie Mellon University
28: * Date: 7/90
29: */
30: #include "mach_kdb.h"
31: #if MACH_KDB
32:
33: /*
34: * Symbol table routines for a.out format files.
35: */
36:
37: #include <mach/std_types.h>
38: #include <machine/db_machdep.h> /* data types */
39: #include <ddb/db_sym.h>
40:
41: #ifndef DB_NO_AOUT
42:
43: #include <ddb/nlist.h> /* a.out symbol table */
44: #include <ddb/stab.h>
45:
46: #define private static
47:
48: /*
49: * An a.out symbol table as loaded into the kernel debugger:
50: *
51: * symtab -> size of symbol entries, in bytes
52: * sp -> first symbol entry
53: * ...
54: * ep -> last symbol entry + 1
55: * strtab == start of string table
56: * size of string table in bytes,
57: * including this word
58: * -> strings
59: */
60:
61: /*
62: * Find pointers to the start and end of the symbol entries,
63: * given a pointer to the start of the symbol table.
64: */
65: #define db_get_aout_symtab(symtab, sp, ep) \
66: (sp = (struct nlist *)((vm_offset_t *)(symtab) + 1), \
67: ep = (struct nlist *)((char *)sp + *((int*)symtab)))
68:
69: boolean_t
70: aout_db_sym_init(symtab, esymtab, name, task_addr)
71: char * symtab; /* pointer to start of symbol table */
72: char * esymtab; /* pointer to end of string table,
73: for checking - may be rounded up to
74: integer boundary */
75: char * name;
76: char * task_addr; /* use for this task only */
77: {
78: register struct nlist *sym_start, *sym_end;
79: register struct nlist *sp;
80: register char * strtab;
81: register int strlen;
82: char * estrtab;
83:
84: db_get_aout_symtab(symtab, sym_start, sym_end);
85:
86: strtab = (char *)sym_end;
87: strlen = *(int *)strtab;
88: estrtab = strtab + strlen;
89:
90: #define round_to_size(x) \
91: (((vm_offset_t)(x) + sizeof(vm_size_t) - 1) & ~(sizeof(vm_size_t) - 1))
92:
93: if (round_to_size(estrtab) != round_to_size(esymtab)) {
94: db_printf("[ %s symbol table not valid ]\n", name);
95: return (FALSE);
96: }
97:
98: #undef round_to_size
99:
100: for (sp = sym_start; sp < sym_end; sp++) {
101: register long strx;
102: strx = sp->n_un.n_strx;
103: if (strx != 0) {
104: if (strx > strlen) {
105: db_printf("Bad string table index (%#x)\n", strx);
106: sp->n_un.n_name = 0;
107: continue;
108: }
109: sp->n_un.n_name = strtab + strx;
110: }
111: }
112:
113: if (db_add_symbol_table(SYMTAB_AOUT,
114: (char *)sym_start,
115: (char *)sym_end,
116: name,
117: symtab,
118: task_addr))
119: {
120: /* Successfully added symbol table */
121: db_printf("[ preserving %d bytes of %s symbol table ]\n",
122: esymtab - (char *)symtab, name);
123: return TRUE;
124: }
125: else
126: return FALSE;
127: }
128:
129: /*
130: * check file name or not (check xxxx.x pattern)
131: */
132: private boolean_t
133: aout_db_is_filename(name)
134: register char *name;
135: {
136: while (*name) {
137: if (*name == '.') {
138: if (name[1])
139: return(TRUE);
140: }
141: name++;
142: }
143: return(FALSE);
144: }
145:
146: /*
147: * special name comparison routine with a name in the symbol table entry
148: */
149: private boolean_t
150: aout_db_eq_name(sp, name)
151: struct nlist *sp;
152: char *name;
153: {
154: register char *s1, *s2;
155:
156: s1 = sp->n_un.n_name;
157: s2 = name;
158: if (*s1 == '_' && *s2 && *s2 != '_')
159: s1++;
160: while (*s2) {
161: if (*s1++ != *s2++) {
162: /*
163: * check .c .o file name comparison case
164: */
165: if (*s2 == 0 && sp->n_un.n_name <= s1 - 2
166: && s1[-2] == '.' && s1[-1] == 'o')
167: return(TRUE);
168: return(FALSE);
169: }
170: }
171: /*
172: * do special check for
173: * xxx:yyy for N_FUN
174: * xxx.ttt for N_DATA and N_BSS
175: */
176: return(*s1 == 0 || (*s1 == ':' && sp->n_type == N_FUN) ||
177: (*s1 == '.' && (sp->n_type == N_DATA || sp->n_type == N_BSS)));
178: }
179:
180: /*
181: * search a symbol table with name and type
182: * fp(in,out): last found text file name symbol entry
183: */
184: private struct nlist *
185: aout_db_search_name(sp, ep, name, type, fp)
186: register struct nlist *sp;
187: struct nlist *ep;
188: char *name;
189: int type;
190: struct nlist **fp;
191: {
192: struct nlist *file_sp = *fp;
193: struct nlist *found_sp = 0;
194:
195: for ( ; sp < ep; sp++) {
196: if (sp->n_type == N_TEXT && aout_db_is_filename(sp->n_un.n_name))
197: *fp = sp;
198: if (type) {
199: if (sp->n_type == type) {
200: if (aout_db_eq_name(sp, name))
201: return(sp);
202: }
203: if (sp->n_type == N_SO)
204: *fp = sp;
205: continue;
206: }
207: if (sp->n_type & N_STAB)
208: continue;
209: if (sp->n_un.n_name && aout_db_eq_name(sp, name)) {
210: /*
211: * In case of qaulified search by a file,
212: * return it immediately with some check.
213: * Otherwise, search external one
214: */
215: if (file_sp) {
216: if ((file_sp == *fp) || (sp->n_type & N_EXT))
217: return(sp);
218: } else if (sp->n_type & N_EXT)
219: return(sp);
220: else
221: found_sp = sp;
222: }
223: }
224: return(found_sp);
225: }
226:
227: /*
228: * search a symbol with file, func and line qualification
229: */
230: private db_sym_t
231: aout_db_qualified_search(stab, file, sym, line)
232: db_symtab_t *stab;
233: char *file;
234: char *sym;
235: int line;
236: {
237: register struct nlist *sp = (struct nlist *)stab->start;
238: struct nlist *ep = (struct nlist *)stab->end;
239: struct nlist *fp = 0;
240: struct nlist *found_sp;
241: unsigned long func_top;
242: boolean_t in_file;
243:
244: if (file == 0 && sym == 0)
245: return(0);
246: if (file) {
247: if ((sp = aout_db_search_name(sp, ep, file, N_TEXT, &fp)) == 0)
248: return(0);
249: }
250: if (sym) {
251: sp = aout_db_search_name(sp, ep, sym, (line > 0)? N_FUN: 0, &fp);
252: if (sp == 0)
253: return(0);
254: }
255: if (line > 0) {
256: if (file && !aout_db_eq_name(fp, file))
257: return(0);
258: found_sp = 0;
259: if (sp->n_type == N_FUN) {
260: /*
261: * qualified by function name
262: * search backward because line number entries
263: * for the function are above it in this case.
264: */
265: func_top = sp->n_value;
266: for (sp--; sp >= (struct nlist *)stab->start; sp--) {
267: if (sp->n_type != N_SLINE)
268: continue;
269: if (sp->n_value < func_top)
270: break;
271: if (sp->n_desc <= line) {
272: if (found_sp == 0 || found_sp->n_desc < sp->n_desc)
273: found_sp = sp;
274: if (sp->n_desc == line)
275: break;
276: }
277: }
278: if (sp->n_type != N_SLINE || sp->n_value < func_top)
279: return(0);
280: } else {
281: /*
282: * qualified by only file name
283: * search forward in this case
284: */
285: in_file = TRUE;
286: for (sp++; sp < ep; sp++) {
287: if (sp->n_type == N_TEXT
288: && aout_db_is_filename(sp->n_un.n_name))
289: break; /* enter into another file */
290: if (sp->n_type == N_SOL) {
291: in_file = aout_db_eq_name(sp, file);
292: continue;
293: }
294: if (!in_file || sp->n_type != N_SLINE)
295: continue;
296: if (sp->n_desc <= line) {
297: if (found_sp == 0 || found_sp->n_desc < sp->n_desc)
298: found_sp = sp;
299: if (sp->n_desc == line)
300: break;
301: }
302: }
303: }
304: sp = found_sp;
305: }
306: return((db_sym_t) sp);
307: }
308:
309: /*
310: * lookup symbol by name
311: */
312: db_sym_t
313: aout_db_lookup(stab, symstr)
314: db_symtab_t *stab;
315: char * symstr;
316: {
317: db_sym_t db_sym_parse_and_lookup();
318:
319: return(db_sym_parse_and_lookup(aout_db_qualified_search, stab, symstr));
320: }
321:
322: db_sym_t
323: aout_db_search_symbol(symtab, off, strategy, diffp)
324: db_symtab_t * symtab;
325: register
326: db_addr_t off;
327: db_strategy_t strategy;
328: db_expr_t *diffp; /* in/out */
329: {
330: register unsigned long diff = *diffp;
331: register struct nlist *symp = 0;
332: register struct nlist *sp, *ep;
333:
334: sp = (struct nlist *)symtab->start;
335: ep = (struct nlist *)symtab->end;
336:
337: for (; sp < ep; sp++) {
338: if (sp->n_un.n_name == 0)
339: continue;
340: if ((sp->n_type & N_STAB) != 0)
341: continue;
342: if (strategy == DB_STGY_XTRN && (sp->n_type & N_EXT) == 0)
343: continue;
344: if (off >= sp->n_value) {
345:
346: unsigned int type = sp->n_type;
347:
348: if (type == N_FN) continue;
349: if (off - sp->n_value < diff) {
350: diff = off - sp->n_value;
351: symp = sp;
352: if (diff == 0 && (type & N_EXT))
353: break;
354: }
355: else if (off - sp->n_value == diff) {
356: if (symp == 0)
357: symp = sp;
358: else if ((symp->n_type & N_EXT) == 0 &&
359: (type & N_EXT) != 0)
360: symp = sp; /* pick the external symbol */
361: }
362: }
363: }
364: if (symp == 0) {
365: *diffp = off;
366: }
367: else {
368: *diffp = diff;
369: }
370: return ((db_sym_t)symp);
371: }
372:
373: /*
374: * Return the name and value for a symbol.
375: */
376: void
377: aout_db_symbol_values(sym, namep, valuep)
378: db_sym_t sym;
379: char **namep;
380: db_expr_t *valuep;
381: {
382: register struct nlist *sp;
383:
384: sp = (struct nlist *)sym;
385: if (namep)
386: *namep = sp->n_un.n_name;
387: if (valuep)
388: *valuep = sp->n_value;
389: }
390:
391: #define X_DB_MAX_DIFF 8 /* maximum allowable diff at the end of line */
392:
393: /*
394: * search symbol by value
395: */
396: private boolean_t
397: aout_db_search_by_addr(stab, addr, file, func, line, diff)
398: db_symtab_t *stab;
399: register vm_offset_t addr;
400: char **file;
401: char **func;
402: int *line;
403: unsigned long *diff;
404: {
405: register struct nlist *sp;
406: register struct nlist *line_sp, *func_sp, *file_sp, *line_func;
407: register vm_size_t func_diff, line_diff;
408: boolean_t found_line = FALSE;
409: struct nlist *ep = (struct nlist *)stab->end;
410:
411: line_sp = func_sp = file_sp = line_func = 0;
412: *file = *func = 0;
413: *line = 0;
414: func_diff = line_diff = ~0;
415: for (sp = (struct nlist *)stab->start; sp < ep; sp++) {
416: switch(sp->n_type) {
417: case N_SLINE:
418: if (sp->n_value <= addr) {
419: if (line_sp == 0 || line_diff >= addr - sp->n_value) {
420: if (line_func)
421: line_func = 0;
422: line_sp = sp;
423: line_diff = addr - sp->n_value;
424: }
425: }
426: if (sp->n_value >= addr && line_sp)
427: found_line = TRUE;
428: continue;
429: case N_FUN:
430: if ((found_line || (line_sp && line_diff < X_DB_MAX_DIFF))
431: && line_func == 0)
432: line_func = sp;
433: continue;
434: case N_SO:
435: if (sp->n_value > addr)
436: continue;
437: if (file_sp == 0 || file_sp->n_value <= sp->n_value)
438: file_sp = sp;
439: continue;
440: case N_TEXT:
441: if (aout_db_is_filename(sp->n_un.n_name)) {
442: if (sp->n_value > addr)
443: continue;
444: if (file_sp == 0 || file_sp->n_value <= sp->n_value)
445: file_sp = sp;
446: } else if (sp->n_value <= addr &&
447: (func_sp == 0 || func_diff > addr - sp->n_value)) {
448: func_sp = sp;
449: func_diff = addr - sp->n_value;
450: }
451: continue;
452: case N_TEXT|N_EXT:
453: if (sp->n_value <= addr &&
454: (func_sp == 0 || func_diff >= addr - sp->n_value)) {
455: func_sp = sp;
456: func_diff = addr - sp->n_value;
457: if (func_diff == 0 && file_sp && func_sp)
458: break;
459: }
460: default:
461: continue;
462: }
463: break;
464: }
465: if (line_sp) {
466: if (line_func == 0 || func_sp == 0
467: || line_func->n_value != func_sp->n_value)
468: line_sp = 0;
469: }
470: if (file_sp) {
471: *diff = addr - file_sp->n_value;
472: *file = file_sp->n_un.n_name;
473: }
474: if (func_sp) {
475: *diff = addr - func_sp->n_value;
476: *func = (func_sp->n_un.n_name[0] == '_')?
477: func_sp->n_un.n_name + 1: func_sp->n_un.n_name;
478: }
479: if (line_sp) {
480: *diff = addr - line_sp->n_value;
481: *line = line_sp->n_desc;
482: }
483: return(file_sp || func_sp || line_sp);
484: }
485:
486: /*
487: * Find filename and lineno within, given the current pc.
488: */
489: boolean_t
490: aout_db_line_at_pc(stab, sym, file, line, pc)
491: db_symtab_t *stab;
492: db_sym_t sym;
493: char **file;
494: int *line;
495: db_expr_t pc;
496: {
497: char *func;
498: unsigned long diff;
499: boolean_t found;
500:
501: found = aout_db_search_by_addr(stab,(vm_offset_t)pc,file,&func,line,&diff);
502: return(found && func && *file);
503: }
504:
505: #endif /* DB_NO_AOUT */
506:
507: #endif MACH_KDB
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.