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