![[BACK]](/icons/back.gif){kind=icon}
Return to db_elf.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / ddb|
Return to db_elf.c CVS log | Up to [local] / sys / ddb |
1.1 nbrk 1: /* $OpenBSD: db_elf.c,v 1.7 2006/03/13 06:23:20 jsg Exp $ */
2: /* $NetBSD: db_elf.c,v 1.13 2000/07/07 21:55:18 jhawk Exp $ */
3:
4: /*-
5: * Copyright (c) 1997 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
10: * NASA Ames Research Center.
11: *
12: * Redistribution and use in source and binary forms, with or without
13: * modification, are permitted provided that the following conditions
14: * are met:
15: * 1. Redistributions of source code must retain the above copyright
16: * notice, this list of conditions and the following disclaimer.
17: * 2. Redistributions in binary form must reproduce the above copyright
18: * notice, this list of conditions and the following disclaimer in the
19: * documentation and/or other materials provided with the distribution.
20: * 3. All advertising materials mentioning features or use of this software
21: * must display the following acknowledgement:
22: * This product includes software developed by the NetBSD
23: * Foundation, Inc. and its contributors.
24: * 4. Neither the name of The NetBSD Foundation nor the names of its
25: * contributors may be used to endorse or promote products derived
26: * from this software without specific prior written permission.
27: *
28: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
29: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
30: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
31: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
32: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
34: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
35: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
36: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
37: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38: * POSSIBILITY OF SUCH DAMAGE.
39: */
40:
41: #include <sys/types.h>
42: #include <sys/param.h>
43: #include <sys/systm.h>
44: #include <sys/proc.h>
45: #include <sys/exec.h>
46:
47: #include <machine/db_machdep.h>
48:
49: #include <ddb/db_sym.h>
50: #include <ddb/db_output.h>
51: #include <ddb/db_extern.h>
52:
53: #ifdef DB_ELF_SYMBOLS
54:
55: #ifndef DB_ELFSIZE
56: #error Must define DB_ELFSIZE!
57: #endif
58:
59: #define ELFSIZE DB_ELFSIZE
60:
61: #include <sys/exec_elf.h>
62:
63: static char *db_elf_find_strtab(db_symtab_t *);
64:
65: #define STAB_TO_SYMSTART(stab) ((Elf_Sym *)((stab)->start))
66: #define STAB_TO_SYMEND(stab) ((Elf_Sym *)((stab)->end))
67: #define STAB_TO_EHDR(stab) ((Elf_Ehdr *)((stab)->private))
68: #define STAB_TO_SHDR(stab, e) ((Elf_Shdr *)((stab)->private + (e)->e_shoff))
69:
70: boolean_t db_elf_sym_init(int, void *, void *, const char *);
71: db_sym_t db_elf_lookup(db_symtab_t *, char *);
72: db_sym_t db_elf_search_symbol(db_symtab_t *, db_addr_t,
73: db_strategy_t, db_expr_t *);
74: void db_elf_symbol_values(db_symtab_t *, db_sym_t,
75: char **, db_expr_t *);
76: boolean_t db_elf_line_at_pc(db_symtab_t *, db_sym_t,
77: char **, int *, db_expr_t);
78: boolean_t db_elf_sym_numargs(db_symtab_t *, db_sym_t, int *,
79: char **);
80: void db_elf_forall(db_symtab_t *,
81: db_forall_func_t db_forall_func, void *);
82:
83: db_symformat_t db_symformat_elf = {
84: "ELF",
85: db_elf_sym_init,
86: db_elf_lookup,
87: db_elf_search_symbol,
88: db_elf_symbol_values,
89: db_elf_line_at_pc,
90: db_elf_sym_numargs,
91: db_elf_forall
92: };
93:
94: /*
95: * Find the symbol table and strings; tell ddb about them.
96: *
97: * symsize: size of symbol table
98: * symtab: pointer to start of symbol table
99: * esymtab: pointer to end of string table, for checking - rounded up to
100: * integer boundry
101: */
102: boolean_t
103: db_elf_sym_init(int symsize, void *symtab, void *esymtab, const char *name)
104: {
105: Elf_Ehdr *elf;
106: Elf_Shdr *shp;
107: Elf_Sym *symp, *symtab_start, *symtab_end;
108: char *shstrtab, *strtab_start, *strtab_end;
109: int i;
110: char *errstr = "";
111:
112: if (ALIGNED_POINTER(symtab, long) == 0) {
113: printf("[ %s symbol table has bad start address %p ]\n",
114: name, symtab);
115: return (FALSE);
116: }
117:
118: symtab_start = symtab_end = NULL;
119: strtab_start = strtab_end = NULL;
120:
121: /*
122: * The format of the symbols loaded by the boot program is:
123: *
124: * Elf exec header
125: * first section header
126: * . . .
127: * . . .
128: * last section header
129: * first symbol or string table section
130: * . . .
131: * . . .
132: * last symbol or string table section
133: */
134:
135: /*
136: * Validate the Elf header.
137: */
138: elf = (Elf_Ehdr *)symtab;
139: if (memcmp(elf->e_ident, ELFMAG, SELFMAG) != 0 ||
140: elf->e_ident[EI_CLASS] != ELFCLASS) {
141: errstr = "bad magic";
142: goto badheader;
143: }
144:
145: if (elf->e_machine != ELF_TARG_MACH) {
146: errstr = "bad e_machine";
147: goto badheader;
148: }
149:
150: /*
151: * Find the section header string table (.shstrtab), and look up
152: * the symbol table (.symtab) and string table (.strtab) via their
153: * names in shstrtab, rather than by table type.
154: * This works in the presence of multiple string tables, such as
155: * stabs data found when booting bsd.gdb.
156: */
157: shp = (Elf_Shdr *)((char *)symtab + elf->e_shoff);
158: shstrtab = (char *)symtab + shp[elf->e_shstrndx].sh_offset;
159: for (i = 0; i < elf->e_shnum; i++) {
160: if (shp[i].sh_type == SHT_SYMTAB) {
161: int j;
162:
163: if (shp[i].sh_offset == 0)
164: continue;
165: symtab_start = (Elf_Sym *)((char *)symtab +
166: shp[i].sh_offset);
167: symtab_end = (Elf_Sym *)((char *)symtab +
168: shp[i].sh_offset + shp[i].sh_size);
169: j = shp[i].sh_link;
170: if (shp[j].sh_offset == 0)
171: continue;
172: strtab_start = (char *)symtab + shp[j].sh_offset;
173: strtab_end = (char *)symtab + shp[j].sh_offset +
174: shp[j].sh_size;
175: break;
176: }
177:
178: /*
179: * This is the old way of doing things.
180: * XXX - verify that it's not needed.
181: */
182: if (strcmp(".strtab", shstrtab+shp[i].sh_name) == 0) {
183: strtab_start = (char *)symtab + shp[i].sh_offset;
184: strtab_end = (char *)symtab + shp[i].sh_offset +
185: shp[i].sh_size;
186: } else if (strcmp(".symtab", shstrtab+shp[i].sh_name) == 0) {
187: symtab_start = (Elf_Sym *)((char *)symtab +
188: shp[i].sh_offset);
189: symtab_end = (Elf_Sym *)((char *)symtab +
190: shp[i].sh_offset + shp[i].sh_size);
191: }
192: }
193:
194: /*
195: * Now, sanity check the symbols against the string table.
196: */
197: if (symtab_start == NULL || strtab_start == NULL ||
198: ALIGNED_POINTER(symtab_start, long) == 0 ||
199: ALIGNED_POINTER(strtab_start, long) == 0) {
200: errstr = "symtab unaligned";
201: goto badheader;
202: }
203: for (symp = symtab_start; symp < symtab_end; symp++)
204: if (symp->st_name + strtab_start > strtab_end) {
205: errstr = "symtab corrupted";
206: goto badheader;
207: }
208:
209: /*
210: * Link the symbol table into the debugger.
211: */
212: if (db_add_symbol_table((char *)symtab_start,
213: (char *)symtab_end, name, (char *)symtab) != -1) {
214: printf("[ using %lu bytes of %s ELF symbol table ]\n",
215: (u_long)roundup(((char *)esymtab - (char *)symtab),
216: sizeof(u_long)), name);
217: return (TRUE);
218: }
219:
220: return (FALSE);
221:
222: badheader:
223: printf("[ %s ELF symbol table not valid: %s ]\n", name, errstr);
224: return (FALSE);
225: }
226:
227: /*
228: * Internal helper function - return a pointer to the string table
229: * for the current symbol table.
230: */
231: static char *
232: db_elf_find_strtab(db_symtab_t *stab)
233: {
234: Elf_Ehdr *elf = STAB_TO_EHDR(stab);
235: Elf_Shdr *shp = STAB_TO_SHDR(stab, elf);
236: char *shstrtab;
237: int i;
238:
239: shstrtab = (char *)elf + shp[elf->e_shstrndx].sh_offset;
240: for (i = 0; i < elf->e_shnum; i++) {
241: if (shp[i].sh_type == SHT_SYMTAB)
242: return ((char *)elf + shp[shp[i].sh_link].sh_offset);
243: if (strcmp(".strtab", shstrtab+shp[i].sh_name) == 0)
244: return ((char *)elf + shp[i].sh_offset);
245: }
246:
247: return (NULL);
248: }
249:
250: /*
251: * Lookup the symbol with the given name.
252: */
253: db_sym_t
254: db_elf_lookup(db_symtab_t *stab, char *symstr)
255: {
256: Elf_Sym *symp, *symtab_start, *symtab_end;
257: char *strtab;
258:
259: symtab_start = STAB_TO_SYMSTART(stab);
260: symtab_end = STAB_TO_SYMEND(stab);
261:
262: strtab = db_elf_find_strtab(stab);
263: if (strtab == NULL)
264: return ((db_sym_t)0);
265:
266: for (symp = symtab_start; symp < symtab_end; symp++) {
267: if (symp->st_name != 0 &&
268: db_eqname(strtab + symp->st_name, symstr, 0))
269: return ((db_sym_t)symp);
270: }
271:
272: return ((db_sym_t)0);
273: }
274:
275: /*
276: * Search for the symbol with the given address (matching within the
277: * provided threshold).
278: */
279: db_sym_t
280: db_elf_search_symbol(db_symtab_t *symtab, db_addr_t off, db_strategy_t strategy,
281: db_expr_t *diffp)
282: {
283: Elf_Sym *rsymp, *symp, *symtab_start, *symtab_end;
284: db_expr_t diff = *diffp;
285:
286: symtab_start = STAB_TO_SYMSTART(symtab);
287: symtab_end = STAB_TO_SYMEND(symtab);
288:
289: rsymp = NULL;
290:
291: for (symp = symtab_start; symp < symtab_end; symp++) {
292: if (symp->st_name == 0)
293: continue;
294: #if 0
295: /* This prevents me from seeing anythin in locore.s -- eeh */
296: if (ELF_SYM_TYPE(symp->st_info) != Elf_estt_object &&
297: ELF_SYM_TYPE(symp->st_info) != Elf_estt_func)
298: continue;
299: #endif
300:
301: if (off >= symp->st_value) {
302: if ((off - symp->st_value) < diff) {
303: diff = off - symp->st_value;
304: rsymp = symp;
305: if (diff == 0) {
306: if (strategy == DB_STGY_PROC &&
307: ELFDEFNNAME(ST_TYPE)(symp->st_info)
308: == STT_FUNC &&
309: ELFDEFNNAME(ST_BIND)(symp->st_info)
310: != STB_LOCAL)
311: break;
312: if (strategy == DB_STGY_ANY &&
313: ELFDEFNNAME(ST_BIND)(symp->st_info)
314: != STB_LOCAL)
315: break;
316: }
317: } else if ((off - symp->st_value) == diff) {
318: if (rsymp == NULL)
319: rsymp = symp;
320: else if (ELFDEFNNAME(ST_BIND)(rsymp->st_info)
321: == STB_LOCAL &&
322: ELFDEFNNAME(ST_BIND)(symp->st_info)
323: != STB_LOCAL) {
324: /* pick the external symbol */
325: rsymp = symp;
326: }
327: }
328: }
329: }
330:
331: if (rsymp == NULL)
332: *diffp = off;
333: else
334: *diffp = diff;
335:
336: return ((db_sym_t)rsymp);
337: }
338:
339: /*
340: * Return the name and value for a symbol.
341: */
342: void
343: db_elf_symbol_values(db_symtab_t *symtab, db_sym_t sym, char **namep,
344: db_expr_t *valuep)
345: {
346: Elf_Sym *symp = (Elf_Sym *)sym;
347: char *strtab;
348:
349: if (namep) {
350: strtab = db_elf_find_strtab(symtab);
351: if (strtab == NULL)
352: *namep = NULL;
353: else
354: *namep = strtab + symp->st_name;
355: }
356:
357: if (valuep)
358: *valuep = symp->st_value;
359: }
360:
361: /*
362: * Return the file and line number of the current program counter
363: * if we can find the appropriate debugging symbol.
364: */
365: boolean_t
366: db_elf_line_at_pc(db_symtab_t *symtab, db_sym_t cursym, char **filename,
367: int *linenum, db_expr_t off)
368: {
369:
370: /*
371: * XXX We don't support this (yet).
372: */
373: return (FALSE);
374: }
375:
376: /*
377: * Returns the number of arguments to a function and their
378: * names if we can find the appropriate debugging symbol.
379: */
380: boolean_t
381: db_elf_sym_numargs(db_symtab_t *symtab, db_sym_t cursym, int *nargp,
382: char **argnamep)
383: {
384:
385: /*
386: * XXX We don't support this (yet).
387: */
388: return (FALSE);
389: }
390:
391: void
392: db_elf_forall(db_symtab_t *stab, db_forall_func_t db_forall_func, void *arg)
393: {
394: char *strtab;
395: static char suffix[2];
396: Elf_Sym *symp, *symtab_start, *symtab_end;
397:
398: symtab_start = STAB_TO_SYMSTART(stab);
399: symtab_end = STAB_TO_SYMEND(stab);
400:
401: strtab = db_elf_find_strtab(stab);
402: if (strtab == NULL)
403: return;
404:
405: for (symp = symtab_start; symp < symtab_end; symp++)
406: if (symp->st_name != 0) {
407: suffix[1] = '\0';
408: switch (ELFDEFNNAME(ST_TYPE)(symp->st_info)) {
409: case STT_OBJECT:
410: suffix[0] = '+';
411: break;
412: case STT_FUNC:
413: suffix[0] = '*';
414: break;
415: case STT_SECTION:
416: suffix[0] = '&';
417: break;
418: case STT_FILE:
419: suffix[0] = '/';
420: break;
421: default:
422: suffix[0] = '\0';
423: }
424: (*db_forall_func)(stab, (db_sym_t)symp,
425: strtab + symp->st_name, suffix, 0, arg);
426: }
427: return;
428: }
429: #endif /* DB_ELF_SYMBOLS */