db_sym.c revision 1.17
1 /* $NetBSD: db_sym.c,v 1.17 1999/04/12 20:38:21 pk Exp $ */ 2 3 /* 4 * Mach Operating System 5 * Copyright (c) 1991,1990 Carnegie Mellon University 6 * All Rights Reserved. 7 * 8 * Permission to use, copy, modify and distribute this software and its 9 * documentation is hereby granted, provided that both the copyright 10 * notice and this permission notice appear in all copies of the 11 * software, derivative works or modified versions, and any portions 12 * thereof, and that both notices appear in supporting documentation. 13 * 14 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 15 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR 16 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 17 * 18 * Carnegie Mellon requests users of this software to return to 19 * 20 * Software Distribution Coordinator or Software.Distribution (at) CS.CMU.EDU 21 * School of Computer Science 22 * Carnegie Mellon University 23 * Pittsburgh PA 15213-3890 24 * 25 * any improvements or extensions that they make and grant Carnegie the 26 * rights to redistribute these changes. 27 */ 28 29 #include <sys/param.h> 30 #include <sys/proc.h> 31 #include <sys/systm.h> 32 33 #include <machine/db_machdep.h> 34 35 #include <ddb/db_sym.h> 36 #include <ddb/db_output.h> 37 #include <ddb/db_extern.h> 38 #include <ddb/db_command.h> 39 40 /* 41 * Multiple symbol tables 42 */ 43 #ifndef MAXLKMS 44 #define MAXLKMS 20 45 #endif 46 47 #ifndef MAXNOSYMTABS 48 #define MAXNOSYMTABS MAXLKMS+1 /* Room for kernel + LKM's */ 49 #endif 50 51 db_symtab_t db_symtabs[MAXNOSYMTABS] = {{0,},}; 52 53 db_symtab_t *db_last_symtab; 54 55 static char *db_qualify __P((db_sym_t, const char *)); 56 57 /* 58 * Put the most picky symbol table formats at the top! 59 */ 60 const db_symformat_t *db_symformats[] = { 61 #ifdef DB_ELF_SYMBOLS 62 &db_symformat_elf, 63 #endif 64 #ifdef DB_AOUT_SYMBOLS 65 &db_symformat_aout, 66 #endif 67 NULL, 68 }; 69 70 const db_symformat_t *db_symformat; 71 72 boolean_t X_db_sym_init __P((int, void *, void *, const char *)); 73 db_sym_t X_db_lookup __P((db_symtab_t *, char *)); 74 db_sym_t X_db_search_symbol __P((db_symtab_t *, db_addr_t, 75 db_strategy_t, db_expr_t *)); 76 void X_db_symbol_values __P((db_symtab_t *, db_sym_t, char **, 77 db_expr_t *)); 78 boolean_t X_db_line_at_pc __P((db_symtab_t *, db_sym_t, char **, 79 int *, db_expr_t)); 80 int X_db_sym_numargs __P((db_symtab_t *, db_sym_t, int *, 81 char **)); 82 83 /* 84 * Initialize the kernel debugger by initializing the master symbol 85 * table. Note that if initializing the master symbol table fails, 86 * no other symbol tables can be loaded. 87 */ 88 void 89 ddb_init(symsize, vss, vse) 90 int symsize; 91 void *vss, *vse; 92 { 93 const db_symformat_t **symf; 94 const char *name = "netbsd"; 95 96 if (symsize <= 0) { 97 printf(" [ no symbols available ]\n"); 98 return; 99 } 100 101 /* 102 * Do this check now for the master symbol table to avoid printing 103 * the message N times. 104 */ 105 if (ALIGNED_POINTER(vss, long) == 0) { 106 printf("[ %s symbol table nas bad start address %p ]\n", 107 name, vss); 108 return; 109 } 110 111 for (symf = db_symformats; *symf != NULL; symf++) { 112 db_symformat = *symf; 113 if (X_db_sym_init(symsize, vss, vse, name) == TRUE) 114 return; 115 } 116 117 db_symformat = NULL; 118 printf("[ no symbol table formats found ]\n"); 119 } 120 121 /* 122 * Add symbol table, with given name, to list of symbol tables. 123 */ 124 int 125 db_add_symbol_table(start, end, name, ref) 126 char *start; 127 char *end; 128 const char *name; 129 char *ref; 130 { 131 int slot; 132 133 for (slot = 0; slot < MAXNOSYMTABS; slot++) { 134 if (db_symtabs[slot].name == NULL) 135 break; 136 } 137 if (slot >= MAXNOSYMTABS) { 138 db_printf("No slots left for %s symbol table", name); 139 return(-1); 140 } 141 142 db_symtabs[slot].start = start; 143 db_symtabs[slot].end = end; 144 db_symtabs[slot].name = name; 145 db_symtabs[slot].private = ref; 146 147 return(slot); 148 } 149 150 /* 151 * Delete a symbol table. Caller is responsible for freeing storage. 152 */ 153 void 154 db_del_symbol_table(name) 155 char *name; 156 { 157 int slot; 158 159 for (slot = 0; slot < MAXNOSYMTABS; slot++) { 160 if (db_symtabs[slot].name && 161 ! strcmp(db_symtabs[slot].name, name)) 162 break; 163 } 164 if (slot >= MAXNOSYMTABS) { 165 db_printf("Unable to find symbol table slot for %s.", name); 166 return; 167 } 168 169 db_symtabs[slot].start = 0; 170 db_symtabs[slot].end = 0; 171 db_symtabs[slot].name = 0; 172 db_symtabs[slot].private = 0; 173 } 174 175 /* 176 * db_qualify("vm_map", "netbsd") returns "netbsd:vm_map". 177 * 178 * Note: return value points to static data whose content is 179 * overwritten by each call... but in practice this seems okay. 180 */ 181 static char * 182 db_qualify(sym, symtabname) 183 db_sym_t sym; 184 const char *symtabname; 185 { 186 char *symname; 187 static char tmp[256]; 188 register char *s; 189 190 db_symbol_values(sym, &symname, 0); 191 s = tmp; 192 while ((*s++ = *symtabname++) != '\0') 193 ; 194 s[-1] = ':'; 195 while ((*s++ = *symname++) != '\0') 196 ; 197 return tmp; 198 } 199 200 201 boolean_t 202 db_eqname(src, dst, c) 203 char *src; 204 char *dst; 205 int c; 206 { 207 if (!strcmp(src, dst)) 208 return (TRUE); 209 if (src[0] == c) 210 return (!strcmp(src+1,dst)); 211 return (FALSE); 212 } 213 214 boolean_t 215 db_value_of_name(name, valuep) 216 char *name; 217 db_expr_t *valuep; 218 { 219 db_sym_t sym; 220 221 sym = db_lookup(name); 222 if (sym == DB_SYM_NULL) 223 return (FALSE); 224 db_symbol_values(sym, &name, valuep); 225 return (TRUE); 226 } 227 228 229 /* 230 * Lookup a symbol. 231 * If the symbol has a qualifier (e.g., ux:vm_map), 232 * then only the specified symbol table will be searched; 233 * otherwise, all symbol tables will be searched. 234 */ 235 db_sym_t 236 db_lookup(symstr) 237 char *symstr; 238 { 239 db_sym_t sp; 240 register int i; 241 int symtab_start = 0; 242 int symtab_end = MAXNOSYMTABS; 243 register char *cp; 244 245 /* 246 * Look for, remove, and remember any symbol table specifier. 247 */ 248 for (cp = symstr; *cp; cp++) { 249 if (*cp == ':') { 250 *cp = '\0'; 251 for (i = 0; i < MAXNOSYMTABS; i++) { 252 if (db_symtabs[i].name && 253 ! strcmp(symstr, db_symtabs[i].name)) { 254 symtab_start = i; 255 symtab_end = i + 1; 256 break; 257 } 258 } 259 *cp = ':'; 260 if (i == MAXNOSYMTABS) { 261 db_error("invalid symbol table name"); 262 /*NOTREACHED*/ 263 } 264 symstr = cp+1; 265 } 266 } 267 268 /* 269 * Look in the specified set of symbol tables. 270 * Return on first match. 271 */ 272 for (i = symtab_start; i < symtab_end; i++) { 273 if (db_symtabs[i].name && 274 (sp = X_db_lookup(&db_symtabs[i], symstr))) { 275 db_last_symtab = &db_symtabs[i]; 276 return sp; 277 } 278 } 279 return 0; 280 } 281 282 /* 283 * Does this symbol name appear in more than one symbol table? 284 * Used by db_symbol_values to decide whether to qualify a symbol. 285 */ 286 boolean_t db_qualify_ambiguous_names = FALSE; 287 288 boolean_t 289 db_symbol_is_ambiguous(sym) 290 db_sym_t sym; 291 { 292 char *sym_name; 293 register int i; 294 register 295 boolean_t found_once = FALSE; 296 297 if (!db_qualify_ambiguous_names) 298 return FALSE; 299 300 db_symbol_values(sym, &sym_name, 0); 301 for (i = 0; i < MAXNOSYMTABS; i++) { 302 if (db_symtabs[i].name && 303 X_db_lookup(&db_symtabs[i], sym_name)) { 304 if (found_once) 305 return TRUE; 306 found_once = TRUE; 307 } 308 } 309 return FALSE; 310 } 311 312 /* 313 * Find the closest symbol to val, and return its name 314 * and the difference between val and the symbol found. 315 */ 316 db_sym_t 317 db_search_symbol( val, strategy, offp) 318 register db_addr_t val; 319 db_strategy_t strategy; 320 db_expr_t *offp; 321 { 322 register 323 unsigned int diff; 324 db_expr_t newdiff; 325 register int i; 326 db_sym_t ret = DB_SYM_NULL, sym; 327 328 newdiff = diff = ~0; 329 db_last_symtab = 0; 330 for (i = 0; i < MAXNOSYMTABS; i++) { 331 if (!db_symtabs[i].name) 332 continue; 333 sym = X_db_search_symbol(&db_symtabs[i], val, strategy, &newdiff); 334 if (newdiff < diff) { 335 db_last_symtab = &db_symtabs[i]; 336 diff = newdiff; 337 ret = sym; 338 } 339 } 340 *offp = diff; 341 return ret; 342 } 343 344 /* 345 * Return name and value of a symbol 346 */ 347 void 348 db_symbol_values(sym, namep, valuep) 349 db_sym_t sym; 350 char **namep; 351 db_expr_t *valuep; 352 { 353 db_expr_t value; 354 355 if (sym == DB_SYM_NULL) { 356 *namep = 0; 357 return; 358 } 359 360 X_db_symbol_values(db_last_symtab, sym, namep, &value); 361 362 if (db_symbol_is_ambiguous(sym)) 363 *namep = db_qualify(sym, db_last_symtab->name); 364 if (valuep) 365 *valuep = value; 366 } 367 368 369 /* 370 * Print a the closest symbol to value 371 * 372 * After matching the symbol according to the given strategy 373 * we print it in the name+offset format, provided the symbol's 374 * value is close enough (eg smaller than db_maxoff). 375 * We also attempt to print [filename:linenum] when applicable 376 * (eg for procedure names). 377 * 378 * If we could not find a reasonable name+offset representation, 379 * then we just print the value in hex. Small values might get 380 * bogus symbol associations, e.g. 3 might get some absolute 381 * value like _INCLUDE_VERSION or something, therefore we do 382 * not accept symbols whose value is zero (and use plain hex). 383 * Also, avoid printing as "end+0x????" which is useless. 384 * The variable db_lastsym is used instead of "end" in case we 385 * add support for symbols in loadable driver modules. 386 */ 387 extern char end[]; 388 unsigned long db_lastsym = (unsigned long)end; 389 unsigned int db_maxoff = 0x10000000; 390 391 392 void 393 db_printsym(off, strategy) 394 db_expr_t off; 395 db_strategy_t strategy; 396 { 397 db_expr_t d; 398 char *filename; 399 char *name; 400 db_expr_t value; 401 int linenum; 402 db_sym_t cursym; 403 404 if (off <= db_lastsym) { 405 cursym = db_search_symbol(off, strategy, &d); 406 db_symbol_values(cursym, &name, &value); 407 if (name && (d < db_maxoff) && value) { 408 db_printf("%s", name); 409 if (d) 410 db_printf("+%#lr", d); 411 if (strategy == DB_STGY_PROC) { 412 if (db_line_at_pc(cursym, &filename, &linenum, off)) 413 db_printf(" [%s:%d]", filename, linenum); 414 } 415 return; 416 } 417 } 418 db_printf("%#ln", off); 419 return; 420 } 421 422 423 boolean_t 424 db_line_at_pc( sym, filename, linenum, pc) 425 db_sym_t sym; 426 char **filename; 427 int *linenum; 428 db_expr_t pc; 429 { 430 return X_db_line_at_pc( db_last_symtab, sym, filename, linenum, pc); 431 } 432 433 int 434 db_sym_numargs(sym, nargp, argnames) 435 db_sym_t sym; 436 int *nargp; 437 char **argnames; 438 { 439 return X_db_sym_numargs(db_last_symtab, sym, nargp, argnames); 440 } 441 442 boolean_t 443 X_db_sym_init(symsize, vss, vse, name) 444 int symsize; 445 void *vss, *vse; 446 const char *name; 447 { 448 449 if (db_symformat != NULL) 450 return ((*db_symformat->sym_init)(symsize, vss, vse, name)); 451 return (FALSE); 452 } 453 454 db_sym_t 455 X_db_lookup(stab, symstr) 456 db_symtab_t *stab; 457 char *symstr; 458 { 459 460 if (db_symformat != NULL) 461 return ((*db_symformat->sym_lookup)(stab, symstr)); 462 return ((db_sym_t)0); 463 } 464 465 db_sym_t 466 X_db_search_symbol(stab, off, strategy, diffp) 467 db_symtab_t *stab; 468 db_addr_t off; 469 db_strategy_t strategy; 470 db_expr_t *diffp; 471 { 472 473 if (db_symformat != NULL) 474 return ((*db_symformat->sym_search)(stab, off, strategy, 475 diffp)); 476 return ((db_sym_t)0); 477 } 478 479 void 480 X_db_symbol_values(stab, sym, namep, valuep) 481 db_symtab_t *stab; 482 db_sym_t sym; 483 char **namep; 484 db_expr_t *valuep; 485 { 486 487 if (db_symformat != NULL) 488 (*db_symformat->sym_value)(stab, sym, namep, valuep); 489 } 490 491 boolean_t 492 X_db_line_at_pc(stab, cursym, filename, linenum, off) 493 db_symtab_t *stab; 494 db_sym_t cursym; 495 char **filename; 496 int *linenum; 497 db_expr_t off; 498 { 499 500 if (db_symformat != NULL) 501 return ((*db_symformat->sym_line_at_pc)(stab, cursym, 502 filename, linenum, off)); 503 return (FALSE); 504 } 505 506 boolean_t 507 X_db_sym_numargs(stab, cursym, nargp, argnamep) 508 db_symtab_t *stab; 509 db_sym_t cursym; 510 int *nargp; 511 char **argnamep; 512 { 513 514 if (db_symformat != NULL) 515 return ((*db_symformat->sym_numargs)(stab, cursym, nargp, 516 argnamep)); 517 return (FALSE); 518 } 519
Indexes created Tue Sep 23 07:09:52 GMT 2025