![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to db_gcc_aout.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / osfmk / i386|
Return to db_gcc_aout.c CVS log | Up to [Apple XNU] / XNU / osfmk / i386 |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*
23: * COPYRIGHT NOTICE
24: *
25: * Copyright (c) 1990, 1991, 1992, 1993 Open Software Foundation, Inc.
26: *
27: * Permission is hereby granted to use, copy, modify and freely distribute
28: * the software in this file and its documentation for any purpose without
29: * fee, provided that the above copyright notice appears in all copies and
30: * that both the copyright notice and this permission notice appear in
31: * supporting documentation. Further, provided that the name of Open
32: * Software Foundation, Inc. ("OSF") not be used in advertising or
33: * publicity pertaining to distribution of the software without prior
34: * written permission from OSF. OSF makes no representations about the
35: * suitability of this software for any purpose. It is provided "as is"
36: * without express or implied warranty.
37: */
38: /*
39: * HISTORY
40: *
41: * Revision 1.1.1.1 1998/09/22 21:05:36 wsanchez
42: * Import of Mac OS X kernel (~semeria)
43: *
44: * Revision 1.1.1.1 1998/03/07 02:25:37 wsanchez
45: * Import of OSF Mach kernel (~mburg)
46: *
47: * Revision 1.2.2.3 1994/01/28 17:23:00 chasb
48: * Expand Copyrights
49: * [1994/01/27 19:40:16 chasb]
50: *
51: * Revision 1.2.2.2 1993/06/09 02:27:36 gm
52: * Added to OSF/1 R1.3 from NMK15.0.
53: * [1993/06/02 21:04:03 jeffc]
54: *
55: * Revision 1.2 1993/04/19 16:13:10 devrcs
56: * pick up file_io.h from bootstrap directory
57: * [1993/02/27 15:01:09 david]
58: *
59: * Added new arguments and a missing one to db_add_symbol_table
60: * [[email protected]]
61: * [92/12/03 bernadat]
62: *
63: * Added gcc symbol table handling based on db_aout.c (Revsion 2.4)
64: * [91/07/31 tak]
65: *
66: * Revision 1.1 1992/09/30 02:02:23 robert
67: * Initial revision
68: *
69: * $EndLog$
70: */
71: /* CMU_HIST */
72: /*
73: * Revision 2.1 91/07/31 13:13:51 jeffreyh
74: * Created.
75: *
76: * 31-Jul-91 Jeffrey Heller (tak) at Open Software Foundation
77: * Added gcc symbol table handling based on db_aout.c (Revsion 2.4)
78: *
79: */
80: /* CMU_ENDHIST */
81: /*
82: * Mach Operating System
83: * Copyright (c) 1991,1990 Carnegie Mellon University
84: * All Rights Reserved.
85: *
86: * Permission to use, copy, modify and distribute this software and its
87: * documentation is hereby granted, provided that both the copyright
88: * notice and this permission notice appear in all copies of the
89: * software, derivative works or modified versions, and any portions
90: * thereof, and that both notices appear in supporting documentation.
91: *
92: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
93: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
94: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
95: *
96: * Carnegie Mellon requests users of this software to return to
97: *
98: * Software Distribution Coordinator or [email protected]
99: * School of Computer Science
100: * Carnegie Mellon University
101: * Pittsburgh PA 15213-3890
102: *
103: * any improvements or extensions that they make and grant Carnegie Mellon
104: * the rights to redistribute these changes.
105: */
106: /*
107: */
108: /*
109: * Symbol table routines for a.out format files.
110: */
111:
112: #include <mach/boolean.h>
113: #include <machine/db_machdep.h> /* data types */
114: #include <ddb/db_sym.h>
115:
116: #ifdef DB_GCC_AOUT
117:
118: #include <ddb/nlist.h> /* a.out symbol table */
119: #include <i386/stab.h>
120:
121: /*
122: * An a.out symbol table as loaded into the kernel debugger:
123: *
124: * symtab -> size of symbol entries, in bytes
125: * sp -> first symbol entry
126: * ...
127: * ep -> last symbol entry + 1
128: * strtab == start of string table
129: * size of string table in bytes,
130: * including this word
131: * -> strings
132: */
133:
134: /*
135: * Find pointers to the start and end of the symbol entries,
136: * given a pointer to the start of the symbol table.
137: */
138: #define db_get_aout_symtab(symtab, sp, ep) \
139: (sp = (struct nlist *)((symtab) + 1), \
140: ep = (struct nlist *)((char *)sp + *(symtab)))
141:
142: X_db_sym_init(symtab, esymtab, name)
143: int * symtab; /* pointer to start of symbol table */
144: char * esymtab; /* pointer to end of string table,
145: for checking - rounded up to integer
146: boundary */
147: char * name;
148: {
149: register struct nlist *sym_start, *sym_end;
150: register struct nlist *sp;
151: register char * strtab;
152: register int strlen;
153:
154: db_get_aout_symtab(symtab, sym_start, sym_end);
155:
156: strtab = (char *)sym_end;
157: strlen = *(int *)strtab;
158:
159: if (strtab + ((strlen + sizeof(int) - 1) & ~(sizeof(int)-1))
160: != esymtab)
161: {
162: db_printf("[ %s symbol table not valid ]\n", name);
163: return;
164: }
165:
166: db_printf("[ preserving %#x bytes of %s symbol table ]\n",
167: esymtab - (char *)symtab, name);
168:
169: for (sp = sym_start; sp < sym_end; sp++) {
170: register int strx;
171: strx = sp->n_un.n_strx;
172: if (strx != 0) {
173: if (strx > strlen) {
174: db_printf("Bad string table index (%#x)\n", strx);
175: sp->n_un.n_name = 0;
176: continue;
177: }
178: sp->n_un.n_name = strtab + strx;
179: }
180: }
181:
182: db_add_symbol_table(sym_start, sym_end, name, (char *)symtab,
183: 0, 0, 0, FALSE);
184: }
185:
186: /*
187: * check file name or not (check xxxx.x pattern)
188: */
189: boolean_t
190: X_db_is_filename(name)
191: register char *name;
192: {
193: while (*name) {
194: if (*name == '.') {
195: if (name[1])
196: return(TRUE);
197: }
198: name++;
199: }
200: return(FALSE);
201: }
202:
203: /*
204: * special name comparison routine with a name in the symbol table entry
205: */
206: boolean_t
207: X_db_eq_name(sp, name)
208: struct nlist *sp;
209: char *name;
210: {
211: register char *s1, *s2;
212:
213: s1 = sp->n_un.n_name;
214: s2 = name;
215: if (*s1 == '_' && *s2 && *s2 != '_')
216: s1++;
217: while (*s2) {
218: if (*s1++ != *s2++) {
219: /*
220: * check .c .o file name comparison case
221: */
222: if (*s2 == 0 && sp->n_un.n_name <= s1 - 2
223: && s1[-2] == '.' && s1[-1] == 'o')
224: return(TRUE);
225: return(FALSE);
226: }
227: }
228: /*
229: * do special check for
230: * xxx:yyy for N_FUN
231: * xxx.ttt for N_DATA and N_BSS
232: */
233: return(*s1 == 0 || (*s1 == ':' && sp->n_type == N_FUN) ||
234: (*s1 == '.' && (sp->n_type == N_DATA || sp->n_type == N_BSS)));
235: }
236:
237: /*
238: * search a symbol table with name and type
239: * fp(in,out): last found text file name symbol entry
240: */
241: struct nlist *
242: X_db_search_name(sp, ep, name, type, fp)
243: register struct nlist *sp;
244: struct nlist *ep;
245: char *name;
246: int type;
247: struct nlist **fp;
248: {
249: struct nlist *file_sp = *fp;
250: struct nlist *found_sp = 0;
251:
252: for ( ; sp < ep; sp++) {
253: if (sp->n_type == N_TEXT && X_db_is_filename(sp->n_un.n_name))
254: *fp = sp;
255: if (type) {
256: if (sp->n_type == type) {
257: if (X_db_eq_name(sp, name))
258: return(sp);
259: }
260: if (sp->n_type == N_SO)
261: *fp = sp;
262: continue;
263: }
264: if (sp->n_type & N_STAB)
265: continue;
266: if (sp->n_un.n_name && X_db_eq_name(sp, name)) {
267: /*
268: * In case of qaulified search by a file,
269: * return it immediately with some check.
270: * Otherwise, search external one
271: */
272: if (file_sp) {
273: if ((file_sp == *fp) || (sp->n_type & N_EXT))
274: return(sp);
275: } else if (sp->n_type & N_EXT)
276: return(sp);
277: else
278: found_sp = sp;
279: }
280: }
281: return(found_sp);
282: }
283:
284: /*
285: * search a symbol with file, func and line qualification
286: */
287: struct nlist *
288: X_db_qualified_search(stab, file, sym, line)
289: db_symtab_t *stab;
290: char *file;
291: char *sym;
292: int line;
293: {
294: register struct nlist *sp = (struct nlist *)stab->start;
295: struct nlist *ep = (struct nlist *)stab->end;
296: struct nlist *fp = 0;
297: struct nlist *found_sp;
298: unsigned func_top;
299: boolean_t in_file;
300:
301: if (file == 0 && sym == 0)
302: return(0);
303: if (file) {
304: if ((sp = X_db_search_name(sp, ep, file, N_TEXT, &fp)) == 0)
305: return(0);
306: }
307: if (sym) {
308: sp = X_db_search_name(sp, ep, sym, (line > 0)? N_FUN: 0, &fp);
309: if (sp == 0)
310: return(0);
311: }
312: if (line > 0) {
313: if (file && !X_db_eq_name(fp, file))
314: return(0);
315: found_sp = 0;
316: if (sp->n_type == N_FUN) {
317: /*
318: * qualfied by function name
319: * search backward because line number entries
320: * for the function are above it in this case.
321: */
322: func_top = sp->n_value;
323: for (sp--; sp >= (struct nlist *)stab->start; sp--) {
324: if (sp->n_type != N_SLINE)
325: continue;
326: if (sp->n_value < func_top)
327: break;
328: if (sp->n_desc <= line) {
329: if (found_sp == 0 || found_sp->n_desc < sp->n_desc)
330: found_sp = sp;
331: if (sp->n_desc == line)
332: break;
333: }
334: }
335: if (sp->n_type != N_SLINE || sp->n_value < func_top)
336: return(0);
337: } else {
338: /*
339: * qualified by only file name
340: * search forward in this case
341: */
342: in_file = TRUE;
343: for (sp++; sp < ep; sp++) {
344: if (sp->n_type == N_TEXT
345: && X_db_is_filename(sp->n_un.n_name))
346: break; /* enter into another file */
347: if (sp->n_type == N_SOL) {
348: in_file = X_db_eq_name(sp, file);
349: continue;
350: }
351: if (!in_file || sp->n_type != N_SLINE)
352: continue;
353: if (sp->n_desc <= line) {
354: if (found_sp == 0 || found_sp->n_desc < sp->n_desc)
355: found_sp = sp;
356: if (sp->n_desc == line)
357: break;
358: }
359: }
360: }
361: sp = found_sp;
362: }
363: return(sp);
364: }
365:
366: /*
367: * lookup symbol by name
368: */
369: db_sym_t
370: X_db_lookup(stab, symstr)
371: db_symtab_t *stab;
372: char * symstr;
373: {
374: register char *p;
375: register n;
376: int n_name;
377: int line_number;
378: char *file_name = 0;
379: char *sym_name = 0;
380: char *component[3];
381: struct nlist *found = 0;
382:
383: /*
384: * disassemble component: [file_name:]symbol[:line_nubmer]
385: */
386: component[0] = symstr;
387: component[1] = component[2] = 0;
388: for (p = symstr, n = 1; *p; p++) {
389: if (*p == ':') {
390: if (n >= 3)
391: break;
392: *p = 0;
393: component[n++] = p+1;
394: }
395: }
396: if (*p != 0)
397: goto out;
398: line_number = 0;
399: n_name = n;
400: p = component[n-1];
401: if (*p >= '0' && *p <= '9') {
402: if (n == 1)
403: goto out;
404: for (line_number = 0; *p; p++) {
405: if (*p < '0' || *p > '9')
406: goto out;
407: line_number = line_number*10 + *p - '0';
408: }
409: n_name--;
410: } else if (n >= 3)
411: goto out;
412: if (n_name == 1) {
413: if (X_db_is_filename(component[0])) {
414: file_name = component[0];
415: sym_name = 0;
416: } else {
417: file_name = 0;
418: sym_name = component[0];
419: }
420: } else {
421: file_name = component[0];
422: sym_name = component[1];
423: }
424: found = X_db_qualified_search(stab, file_name, sym_name, line_number);
425:
426: out:
427: while (--n > 1)
428: component[n][-1] = ':';
429: return((db_sym_t) found);
430: }
431:
432: db_sym_t
433: X_db_search_symbol(symtab, off, strategy, diffp)
434: db_symtab_t * symtab;
435: register
436: db_addr_t off;
437: db_strategy_t strategy;
438: db_expr_t *diffp; /* in/out */
439: {
440: register unsigned int diff = *diffp;
441: register struct nlist *symp = 0;
442: register struct nlist *sp, *ep;
443:
444: sp = (struct nlist *)symtab->start;
445: ep = (struct nlist *)symtab->end;
446:
447: for (; sp < ep; sp++) {
448: if (sp->n_un.n_name == 0)
449: continue;
450: if ((sp->n_type & N_STAB) != 0)
451: continue;
452: if (off >= sp->n_value) {
453: if (off - sp->n_value < diff) {
454: diff = off - sp->n_value;
455: symp = sp;
456: if (diff == 0 && (sp->n_type & N_EXT))
457: break;
458: }
459: else if (off - sp->n_value == diff) {
460: if (symp == 0)
461: symp = sp;
462: else if ((symp->n_type & N_EXT) == 0 &&
463: (sp->n_type & N_EXT) != 0)
464: symp = sp; /* pick the external symbol */
465: }
466: }
467: }
468: if (symp == 0) {
469: *diffp = off;
470: }
471: else {
472: *diffp = diff;
473: }
474: return ((db_sym_t)symp);
475: }
476:
477: /*
478: * Return the name and value for a symbol.
479: */
480: void
481: X_db_symbol_values(sym, namep, valuep)
482: db_sym_t sym;
483: char **namep;
484: db_expr_t *valuep;
485: {
486: register struct nlist *sp;
487:
488: sp = (struct nlist *)sym;
489: if (namep)
490: *namep = sp->n_un.n_name;
491: if (valuep)
492: *valuep = sp->n_value;
493: }
494:
495: #define X_DB_MAX_DIFF 8 /* maximum allowable diff at the end of line */
496:
497: /*
498: * search symbol by value
499: */
500: X_db_search_by_addr(stab, addr, file, func, line, diff)
501: db_symtab_t *stab;
502: register unsigned addr;
503: char **file;
504: char **func;
505: int *line;
506: unsigned *diff;
507: {
508: register struct nlist *sp;
509: register struct nlist *line_sp, *func_sp, *file_sp, *line_func;
510: register func_diff, line_diff;
511: boolean_t found_line = FALSE;
512: struct nlist *ep = (struct nlist *)stab->end;
513:
514: line_sp = func_sp = file_sp = line_func = 0;
515: *file = *func = 0;
516: *line = 0;
517: for (sp = (struct nlist *)stab->start; sp < ep; sp++) {
518: switch(sp->n_type) {
519: case N_SLINE:
520: if (sp->n_value <= addr) {
521: if (line_sp == 0 || line_diff >= addr - sp->n_value) {
522: if (line_func)
523: line_func = 0;
524: line_sp = sp;
525: line_diff = addr - sp->n_value;
526: }
527: }
528: if (sp->n_value >= addr && line_sp)
529: found_line = TRUE;
530: continue;
531: case N_FUN:
532: if ((found_line || (line_sp && line_diff < X_DB_MAX_DIFF))
533: && line_func == 0)
534: line_func = sp;
535: continue;
536: case N_TEXT:
537: if (X_db_is_filename(sp->n_un.n_name)) {
538: if (sp->n_value > addr)
539: continue;
540: if (file_sp == 0 || file_sp->n_value < sp->n_value)
541: file_sp = sp;
542: } else if (sp->n_value <= addr &&
543: (func_sp == 0 || func_diff > addr - sp->n_value)) {
544: func_sp = sp;
545: func_diff = addr - sp->n_value;
546: }
547: continue;
548: case N_TEXT|N_EXT:
549: if (sp->n_value <= addr &&
550: (func_sp == 0 || func_diff >= addr - sp->n_value)) {
551: func_sp = sp;
552: func_diff = addr - sp->n_value;
553: if (func_diff == 0 && file_sp && func_sp)
554: break;
555: }
556: default:
557: continue;
558: }
559: break;
560: }
561: if (line_sp) {
562: if (line_func == 0 || func_sp == 0
563: || line_func->n_value != func_sp->n_value)
564: line_sp = 0;
565: }
566: if (file_sp) {
567: *diff = addr - file_sp->n_value;
568: *file = file_sp->n_un.n_name;
569: }
570: if (func_sp) {
571: *diff = addr - func_sp->n_value;
572: *func = (func_sp->n_un.n_name[0] == '_')?
573: func_sp->n_un.n_name + 1: func_sp->n_un.n_name;
574: }
575: if (line_sp) {
576: *diff = addr - line_sp->n_value;
577: *line = line_sp->n_desc;
578: }
579: return(file_sp || func_sp || line_sp);
580: }
581:
582: /* ARGSUSED */
583: boolean_t
584: X_db_line_at_pc(stab, sym, file, line, pc)
585: db_symtab_t *stab;
586: db_sym_t sym;
587: char **file;
588: int *line;
589: db_expr_t pc;
590: {
591: char *func;
592: unsigned diff;
593: boolean_t found;
594:
595: found = X_db_search_by_addr(stab,(unsigned)pc,file,&func,line,&diff);
596: return(found && func && *file);
597: }
598:
599: /*
600: * Initialization routine for a.out files.
601: */
602: kdb_init()
603: {
604: extern char *esym;
605: extern int end;
606:
607: if (esym > (char *)&end) {
608: X_db_sym_init((int *)&end, esym, "mach");
609: }
610: }
611:
612: /*
613: * Read symbol table from file.
614: * (should be somewhere else)
615: */
616: #include <bootstrap/file_io.h>
617: #include <vm/vm_kern.h>
618:
619: read_symtab_from_file(fp, symtab_name)
620: struct file *fp;
621: char * symtab_name;
622: {
623: vm_size_t resid;
624: kern_return_t result;
625: vm_offset_t symoff;
626: vm_size_t symsize;
627: vm_offset_t stroff;
628: vm_size_t strsize;
629: vm_size_t table_size;
630: vm_offset_t symtab;
631:
632: if (!get_symtab(fp, &symoff, &symsize)) {
633: boot_printf("[ error %d reading %s file header ]\n",
634: result, symtab_name);
635: return;
636: }
637:
638: stroff = symoff + symsize;
639: result = read_file(fp, (vm_offset_t)stroff,
640: (vm_offset_t)&strsize, sizeof(strsize), &resid);
641: if (result || resid) {
642: boot_printf("[ no valid symbol table present for %s ]\n",
643: symtab_name);
644: return;
645: }
646:
647: table_size = sizeof(int) + symsize + strsize;
648: table_size = (table_size + sizeof(int)-1) & ~(sizeof(int)-1);
649:
650: result = kmem_alloc_wired(kernel_map, &symtab, table_size);
651: if (result) {
652: boot_printf("[ error %d allocating space for %s symbol table ]\n",
653: result, symtab_name);
654: return;
655: }
656:
657: *(int *)symtab = symsize;
658:
659: result = read_file(fp, symoff,
660: symtab + sizeof(int), symsize, &resid);
661: if (result || resid) {
662: boot_printf("[ error %d reading %s symbol table ]\n",
663: result, symtab_name);
664: return;
665: }
666:
667: result = read_file(fp, stroff,
668: symtab + sizeof(int) + symsize, strsize, &resid);
669: if (result || resid) {
670: boot_printf("[ error %d reading %s string table ]\n",
671: result, symtab_name);
672: return;
673: }
674:
675: X_db_sym_init((int *)symtab,
676: (char *)(symtab + table_size),
677: symtab_name);
678:
679: }
680:
681: #endif /* DB_GCC_AOUT */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.