![[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 [Apple XNU] / XNU / osfmk / ddb|
Return to db_aout.c CVS log | Up to [Apple XNU] / XNU / osfmk / ddb |
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: * @OSF_COPYRIGHT@ ! 24: */ ! 25: /* ! 26: * Mach Operating System ! 27: * Copyright (c) 1991,1990 Carnegie Mellon University ! 28: * All Rights Reserved. ! 29: * ! 30: * Permission to use, copy, modify and distribute this software and its ! 31: * documentation is hereby granted, provided that both the copyright ! 32: * notice and this permission notice appear in all copies of the ! 33: * software, derivative works or modified versions, and any portions ! 34: * thereof, and that both notices appear in supporting documentation. ! 35: * ! 36: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 37: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 38: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 39: * ! 40: * Carnegie Mellon requests users of this software to return to ! 41: * ! 42: * Software Distribution Coordinator or [email protected] ! 43: * School of Computer Science ! 44: * Carnegie Mellon University ! 45: * Pittsburgh PA 15213-3890 ! 46: * ! 47: * any improvements or extensions that they make and grant Carnegie Mellon ! 48: * the rights to redistribute these changes. ! 49: */ ! 50: /* ! 51: */ ! 52: /* ! 53: * Author: David B. Golub, Carnegie Mellon University ! 54: * Date: 7/90 ! 55: */ ! 56: /* ! 57: * Symbol table routines for a.out format files. ! 58: */ ! 59: #include <mach/boolean.h> ! 60: #include <mach/std_types.h> ! 61: #include <machine/db_machdep.h> /* data types */ ! 62: #include <string.h> /* For strcpy(), strcmp() */ ! 63: #include <ddb/db_aout.h> ! 64: #include <ddb/db_output.h> /* For db_printf() */ ! 65: #include <ddb/db_sym.h> ! 66: ! 67: #ifndef DB_NO_AOUT ! 68: ! 69: #include <ddb/nlist.h> /* a.out symbol table */ ! 70: #include <ddb/stab.h> ! 71: ! 72: #define private static ! 73: ! 74: private int aout_db_order_symbols(char *, char *); ! 75: private int aout_db_compare_symbols(char *, char *); ! 76: private boolean_t aout_db_is_filename(char *); ! 77: private boolean_t aout_db_eq_name(struct nlist *, char *, int); ! 78: ! 79: /* ! 80: * An a.out symbol table as loaded into the kernel debugger: ! 81: * ! 82: * symtab -> size of symbol entries, in bytes ! 83: * sp -> first symbol entry ! 84: * ... ! 85: * ep -> last symbol entry + 1 ! 86: * strtab == start of string table ! 87: * size of string table in bytes, ! 88: * including this word ! 89: * -> strings ! 90: */ ! 91: ! 92: /* ! 93: * Find pointers to the start and end of the symbol entries, ! 94: * given a pointer to the start of the symbol table. ! 95: */ ! 96: #define db_get_aout_symtab(symtab, sp, ep) \ ! 97: (sp = (struct nlist *)(((vm_offset_t *)(symtab)) + 1), \ ! 98: ep = (struct nlist *)((char *)sp + *((int *)(symtab)))) ! 99: ! 100: char *db_sorting_sym_end; ! 101: ! 102: private int ! 103: aout_db_order_symbols( ! 104: char *s1, ! 105: char *s2) ! 106: { ! 107: struct nlist *sym1 = (struct nlist *) s1; ! 108: struct nlist *sym2 = (struct nlist *) s2; ! 109: ! 110: if (sym1->n_value != sym2->n_value) ! 111: return (sym1->n_value - sym2->n_value); ! 112: else { ! 113: return (sym1->n_un.n_name - sym2->n_un.n_name); ! 114: } ! 115: } ! 116: ! 117: private int ! 118: aout_db_compare_symbols( ! 119: char *sym1, ! 120: char *sym2) ! 121: { ! 122: return (((struct nlist *) sym1)->n_value - ! 123: ((struct nlist *) sym2)->n_value); ! 124: } ! 125: ! 126: int db_sorting_limit = 50000; ! 127: ! 128: boolean_t ! 129: aout_db_sym_init( ! 130: char * symtab, /* pointer to start of symbol table */ ! 131: char * esymtab, /* pointer to end of string table, ! 132: for checking - may be rounded up to ! 133: integer boundary */ ! 134: char * name, ! 135: char * task_addr) /* use for this task only */ ! 136: { ! 137: struct nlist *sym_start, *sym_end; ! 138: struct nlist *sp; ! 139: char * strtab; ! 140: int strlen; ! 141: char * estrtab; ! 142: unsigned long minsym = ~0; ! 143: unsigned long maxsym = 0; ! 144: boolean_t sorted; ! 145: boolean_t sorting; ! 146: #ifdef __MACHO__ ! 147: extern boolean_t getsymtab(char *, ! 148: vm_offset_t *, int *, ! 149: vm_offset_t *, vm_size_t *); ! 150: int nsyms; ! 151: #endif ! 152: ! 153: ! 154: #ifdef __MACHO__ ! 155: if (!getsymtab(symtab, ! 156: (vm_offset_t *)&sym_start, &nsyms, ! 157: (vm_offset_t *)&strtab, (vm_size_t *)&strlen)) { ! 158: return(FALSE); ! 159: } ! 160: sym_end = sym_start + nsyms; ! 161: estrtab = strtab + strlen; ! 162: #else ! 163: db_get_aout_symtab(symtab, sym_start, sym_end); ! 164: ! 165: db_sorting_sym_end = (char *)sym_end; ! 166: strtab = (char *)sym_end; ! 167: strlen = *(int *)strtab; ! 168: estrtab = strtab + strlen; ! 169: #endif ! 170: ! 171: #ifndef __MACHO__ ! 172: #define round_to_size(x) \ ! 173: (((vm_offset_t)(x) + sizeof(vm_size_t) - 1) & ~(sizeof(vm_size_t) - 1)) ! 174: ! 175: if (round_to_size(estrtab) != round_to_size(esymtab)) ! 176: return (FALSE); ! 177: ! 178: #undef round_to_size ! 179: #endif ! 180: ! 181: sorting = ((sym_end - sym_start) < db_sorting_limit); ! 182: ! 183: for (sp = sym_start; sp < sym_end; sp++) { ! 184: register long strx; ! 185: strx = sp->n_un.n_strx; ! 186: if (strx != 0) { ! 187: if (strx > strlen) { ! 188: sp->n_un.n_name = 0; ! 189: continue; ! 190: } ! 191: sp->n_un.n_name = strtab + strx; ! 192: } ! 193: if (sp->n_type != N_ABS) { ! 194: if (sp->n_value > 0 && sp->n_value < minsym) ! 195: minsym = sp->n_value; ! 196: if (sp->n_value > maxsym) ! 197: maxsym = sp->n_value; ! 198: } ! 199: } ! 200: if (maxsym < minsym) ! 201: minsym = maxsym = 0; ! 202: ! 203: if (sorting) { ! 204: db_qsort((char *) sym_start, sym_end - sym_start, ! 205: sizeof (struct nlist), aout_db_order_symbols); ! 206: sorted = TRUE; ! 207: } else ! 208: sorted = FALSE; ! 209: ! 210: if (db_add_symbol_table(SYMTAB_AOUT, ! 211: (char*)sym_start, ! 212: (char*)sym_end, ! 213: name, ! 214: symtab, ! 215: task_addr, ! 216: minsym, ! 217: maxsym, ! 218: sorted)) ! 219: { ! 220: /* Successfully added symbol table */ ! 221: ! 222: pmap_protect(kernel_pmap, ! 223: (vm_offset_t) sym_start, (vm_offset_t) sym_end, ! 224: VM_PROT_READ|VM_PROT_WRITE); ! 225: pmap_protect(kernel_pmap, ! 226: (vm_offset_t) strtab, (vm_offset_t) estrtab, ! 227: VM_PROT_READ|VM_PROT_WRITE); ! 228: return TRUE; ! 229: } ! 230: return FALSE; ! 231: } ! 232: ! 233: /* ! 234: * This KLUDGE offsets the n_values of a copied symbol table ! 235: */ ! 236: void db_clone_offsetXXX(char *, long); ! 237: void ! 238: db_clone_offsetXXX(char * symtab, long offset) ! 239: { ! 240: register struct nlist *sym_start, *sym_end, *sp; ! 241: ! 242: db_get_aout_symtab((int *)symtab, sym_start, sym_end); ! 243: ! 244: for (sp = sym_start; sp < sym_end; sp++) ! 245: if (sp->n_type != N_ABS) ! 246: sp->n_value += offset; ! 247: } ! 248: /* end KLUDGE */ ! 249: ! 250: /* ! 251: * check file name or not (check xxxx.x pattern) ! 252: */ ! 253: private boolean_t ! 254: aout_db_is_filename(char *name) ! 255: { ! 256: while (*name) { ! 257: if (*name == '.') { ! 258: if (name[1]) ! 259: return(TRUE); ! 260: } ! 261: name++; ! 262: } ! 263: return(FALSE); ! 264: } ! 265: ! 266: /* ! 267: * special name comparison routine with a name in the symbol table entry ! 268: */ ! 269: private boolean_t ! 270: aout_db_eq_name( ! 271: struct nlist *sp, ! 272: char *name, ! 273: int incomplete) ! 274: { ! 275: register char *s1, *s2; ! 276: ! 277: s1 = sp->n_un.n_name; ! 278: s2 = name; ! 279: #ifndef __NO_UNDERSCORES__ ! 280: if (*s1 == '_' && *s2 && *s2 != '_') ! 281: s1++; ! 282: #endif /* __NO_UNDERSCORES__ */ ! 283: while (*s2) { ! 284: if (*s1++ != *s2++) { ! 285: /* ! 286: * check .c .o file name comparison case ! 287: */ ! 288: if (*s2 == 0 && sp->n_un.n_name <= s1 - 2 ! 289: && s1[-2] == '.' && s1[-1] == 'o') ! 290: return(TRUE); ! 291: return(FALSE); ! 292: } ! 293: } ! 294: if (incomplete) ! 295: return(TRUE); ! 296: /* ! 297: * do special check for ! 298: * xxx:yyy for N_FUN ! 299: * xxx.ttt for N_DATA and N_BSS ! 300: */ ! 301: return(*s1 == 0 || (*s1 == ':' && sp->n_type == N_FUN) || ! 302: (*s1 == '.' && (sp->n_type == N_DATA || sp->n_type == N_BSS))); ! 303: } ! 304: ! 305: /* ! 306: * search a symbol table with name and type ! 307: * fp(in,out): last found text file name symbol entry ! 308: */ ! 309: private struct nlist * ! 310: aout_db_search_name( ! 311: struct nlist *sp, ! 312: struct nlist *ep, ! 313: char *name, ! 314: int type, ! 315: struct nlist **fp, ! 316: int incomplete) ! 317: { ! 318: struct nlist *file_sp = *fp; ! 319: struct nlist *found_sp = 0; ! 320: ! 321: for ( ; sp < ep; sp++) { ! 322: if (sp->n_other) ! 323: sp->n_other = 0; ! 324: if (sp->n_type == N_TEXT && aout_db_is_filename(sp->n_un.n_name)) ! 325: *fp = sp; ! 326: if (type) { ! 327: if (sp->n_type == type) { ! 328: /* dwm_debug: b26 name, mk6 added last param */ ! 329: if (aout_db_eq_name(sp, name, 0)) ! 330: return(sp); ! 331: } ! 332: if (sp->n_type == N_SO) ! 333: *fp = sp; ! 334: continue; ! 335: } ! 336: if (sp->n_type & N_STAB) ! 337: continue; ! 338: if (sp->n_un.n_name && aout_db_eq_name(sp, name, incomplete)) { ! 339: /* ! 340: * In case of qaulified search by a file, ! 341: * return it immediately with some check. ! 342: * Otherwise, search external one ! 343: */ ! 344: if (file_sp) { ! 345: if ((file_sp == *fp) || (sp->n_type & N_EXT)) ! 346: return(sp); ! 347: } else if ((sp->n_type & N_EXT) || ! 348: (incomplete && !aout_db_is_filename(sp->n_un.n_name))) ! 349: return(sp); ! 350: else ! 351: found_sp = sp; ! 352: } ! 353: } ! 354: return(found_sp); ! 355: } ! 356: ! 357: /* ! 358: * Print sorted possible completions for a symbol. ! 359: * Use n_other field to mark completion symbols in order ! 360: * to speed up sort. ! 361: */ ! 362: int ! 363: aout_db_qualified_print_completion( ! 364: db_symtab_t *stab, ! 365: char *sym) ! 366: { ! 367: struct nlist *sp; ! 368: struct nlist *sp1; ! 369: struct nlist *ep; ! 370: struct nlist *ep1; ! 371: struct nlist *fp = 0; ! 372: int symlen; ! 373: int nsym = 0; ! 374: struct nlist *cur; ! 375: struct nlist *new; ! 376: char *fname; ! 377: int func; ! 378: int line; ! 379: ! 380: sp = aout_db_search_name((struct nlist *)stab->start, ! 381: (struct nlist *)stab->end, ! 382: sym, 0, &fp, 1); ! 383: if (sp == (struct nlist *)0) ! 384: return 0; ! 385: ! 386: symlen = strlen(sym); ! 387: cur = sp; ! 388: while (cur) { ! 389: if (strncmp(cur->n_un.n_name, sym, symlen) == 0) ! 390: cur->n_other = 1; ! 391: else ! 392: cur->n_other = 2; ! 393: ep = cur; ! 394: cur = aout_db_search_name(cur + 1, (struct nlist *)stab->end, ! 395: sym, 0, &fp, 1); ! 396: } ! 397: ! 398: sp1 = sp; ! 399: for (;;) { ! 400: new = cur = sp; ! 401: while (++cur <= ep) ! 402: if (cur->n_other) { ! 403: if (sp1 == sp) ! 404: sp1 = cur; ! 405: if (strcmp(&cur->n_un.n_name[cur->n_other - 1], ! 406: &new->n_un.n_name[new->n_other - 1]) < 0) ! 407: new = cur; ! 408: else ! 409: ep1 = cur; ! 410: } ! 411: ! 412: func = line = 0; ! 413: if ((new->n_type & N_EXT) == 0) { ! 414: for (cur = new - 1; cur > (struct nlist *)stab->start; cur--) { ! 415: if (cur->n_type == N_SO || ! 416: (stab->sorted && cur->n_value < new->n_value)) ! 417: break; ! 418: if (line == 0 && ! 419: cur->n_type == N_SLINE && ! 420: cur->n_value == new->n_value) ! 421: line = cur->n_desc; ! 422: if (func == 0 && ! 423: cur->n_type == N_FUN && ! 424: cur->n_value == new->n_value) ! 425: func = 1; ! 426: } ! 427: ! 428: if (cur->n_type == N_SO) ! 429: fname = cur->n_un.n_name; ! 430: else ! 431: fname = (char *)0; ! 432: ! 433: if (line == 0 || func == 0) ! 434: for (cur = new + 1; ! 435: cur < (struct nlist *)stab->end; cur++) { ! 436: if (cur->n_type == N_SO || ! 437: (stab->sorted && cur->n_value > new->n_value)) ! 438: break; ! 439: if (line == 0 && ! 440: cur->n_type == N_SLINE && ! 441: cur->n_value == new->n_value) { ! 442: line = cur->n_desc; ! 443: if (func) ! 444: break; ! 445: } ! 446: if (func == 0 && ! 447: cur->n_type == N_FUN && ! 448: cur->n_value == new->n_value) { ! 449: func = 1; ! 450: if (line) ! 451: break; ! 452: } ! 453: } ! 454: } else { ! 455: fname = (char *)0; ! 456: for (cur = new - 1; cur > (struct nlist *)stab->start; cur--) { ! 457: if (cur->n_type == N_SO || ! 458: (stab->sorted && cur->n_value < new->n_value)) ! 459: break; ! 460: if (func == 0 && ! 461: cur->n_type == N_FUN && ! 462: cur->n_value == new->n_value) ! 463: func = 1; ! 464: } ! 465: if (func == 0) ! 466: for (cur = new + 1; ! 467: cur < (struct nlist *)stab->end; cur++) { ! 468: if (cur->n_type == N_SO || ! 469: (stab->sorted && cur->n_value > new->n_value)) ! 470: break; ! 471: if (cur->n_type == N_FUN && ! 472: cur->n_value == new->n_value) { ! 473: func = 1; ! 474: break; ! 475: } ! 476: } ! 477: } ! 478: ! 479: db_sym_print_completion(stab, &new->n_un.n_name[new->n_other - 1], ! 480: func, fname, line); ! 481: nsym++; ! 482: new->n_other = 0; ! 483: ! 484: if (new == sp) { ! 485: if (sp1 == sp) ! 486: break; ! 487: sp = sp1; ! 488: } else if (new == sp1) ! 489: sp1 = sp; ! 490: ! 491: if (new == ep) ! 492: ep = ep1; ! 493: } ! 494: return nsym; ! 495: } ! 496: ! 497: /* ! 498: * search a (possibly incomplete) symbol with file, func and line qualification ! 499: */ ! 500: private int ! 501: aout_db_qualified_search( ! 502: db_symtab_t *stab, ! 503: char *file, ! 504: char *sym, ! 505: int line, ! 506: db_sym_t *ret, ! 507: char **name, ! 508: int *len) ! 509: { ! 510: register struct nlist *sp = (struct nlist *)stab->start; ! 511: struct nlist *ep = (struct nlist *)stab->end; ! 512: struct nlist *fp = 0; ! 513: struct nlist *found_sp; ! 514: unsigned long func_top; ! 515: boolean_t in_file; ! 516: int nsym = 0; ! 517: int i; ! 518: char *p; ! 519: ! 520: if (file == 0 && sym == 0) ! 521: return(0); ! 522: if (file) { ! 523: if ((sp = aout_db_search_name(sp, ep, file, N_TEXT, &fp, 0)) == 0) ! 524: return(0); ! 525: } ! 526: if (sym) { ! 527: for (;;) { ! 528: sp = aout_db_search_name(sp, ep, sym, (line > 0)? N_FUN: 0, &fp, ! 529: (ret == (db_sym_t *)0)); ! 530: if (sp == 0) ! 531: return(nsym); ! 532: if (ret) ! 533: break; ! 534: ! 535: if (strncmp(sp->n_un.n_name, sym, strlen(sym)) == 0) ! 536: p = sp->n_un.n_name; ! 537: else ! 538: p = &sp->n_un.n_name[1]; ! 539: ! 540: if (*name == (char *)0) { ! 541: *name = p; ! 542: *len = strlen(p); ! 543: } else { ! 544: for (i = 0; i < *len; i++) ! 545: if ((*name)[i] != p[i]) { ! 546: *len = i; ! 547: break; ! 548: } ! 549: } ! 550: ! 551: nsym++; ! 552: sp++; ! 553: } ! 554: } ! 555: if (line > 0) { ! 556: if (file && !aout_db_eq_name(fp, file, 0)) ! 557: return(0); ! 558: found_sp = 0; ! 559: if (sp->n_type == N_FUN) { ! 560: /* ! 561: * qualfied by function name ! 562: * search backward because line number entries ! 563: * for the function are above it in this case. ! 564: */ ! 565: func_top = sp->n_value; ! 566: if (stab->sorted) { ! 567: /* symbols with the same value may have been mixed up */ ! 568: do { ! 569: sp++; ! 570: } while (sp->n_value == func_top); ! 571: } ! 572: for (sp--; sp >= (struct nlist *)stab->start; sp--) { ! 573: if (sp->n_type != N_SLINE) ! 574: continue; ! 575: if (sp->n_value < func_top) ! 576: break; ! 577: if (sp->n_desc <= line) { ! 578: if (found_sp == 0 || found_sp->n_desc < sp->n_desc) ! 579: found_sp = sp; ! 580: if (sp->n_desc == line) ! 581: break; ! 582: } ! 583: } ! 584: if (sp->n_type != N_SLINE || sp->n_value < func_top) ! 585: return(0); ! 586: } else { ! 587: /* ! 588: * qualified by only file name ! 589: * search forward in this case ! 590: */ ! 591: in_file = TRUE; ! 592: if (stab->sorted) { ! 593: /* symbols with the same value may have been mixed up */ ! 594: func_top = sp->n_value; ! 595: do { ! 596: sp--; ! 597: } while (sp->n_value == func_top); ! 598: } ! 599: for (sp++; sp < ep; sp++) { ! 600: if (sp->n_type == N_TEXT ! 601: && aout_db_is_filename(sp->n_un.n_name)) ! 602: break; /* enter into another file */ ! 603: if (sp->n_type == N_SOL) { ! 604: in_file = aout_db_eq_name(sp, file, 0); ! 605: continue; ! 606: } ! 607: if (!in_file || sp->n_type != N_SLINE) ! 608: continue; ! 609: if (sp->n_desc <= line) { ! 610: if (found_sp == 0 || found_sp->n_desc < sp->n_desc) ! 611: found_sp = sp; ! 612: if (sp->n_desc == line) ! 613: break; ! 614: } ! 615: } ! 616: } ! 617: sp = found_sp; ! 618: } ! 619: *ret = (db_sym_t) sp; ! 620: return(1); ! 621: } ! 622: ! 623: /* ! 624: * lookup symbol by name ! 625: */ ! 626: db_sym_t ! 627: aout_db_lookup( ! 628: db_symtab_t *stab, ! 629: char * symstr) ! 630: { ! 631: return(db_sym_parse_and_lookup(aout_db_qualified_search, stab, symstr)); ! 632: } ! 633: ! 634: /* ! 635: * lookup (possibly incomplete) symbol by name ! 636: */ ! 637: int ! 638: aout_db_lookup_incomplete( ! 639: db_symtab_t *stab, ! 640: char * symstr, ! 641: char ** name, ! 642: int *len, ! 643: int *toadd) ! 644: { ! 645: return(db_sym_parse_and_lookup_incomplete(aout_db_qualified_search, ! 646: stab, symstr, name, len, toadd)); ! 647: } ! 648: ! 649: /* ! 650: * Display possible completion for the symbol ! 651: */ ! 652: int ! 653: aout_db_print_completion(stab, symstr) ! 654: db_symtab_t *stab; ! 655: char * symstr; ! 656: { ! 657: ! 658: return(db_sym_parse_and_print_completion(aout_db_qualified_print_completion, ! 659: stab, symstr)); ! 660: } ! 661: ! 662: db_sym_t ! 663: aout_db_search_symbol( ! 664: db_symtab_t *symtab, ! 665: db_addr_t off, ! 666: db_strategy_t strategy, ! 667: db_expr_t *diffp) /* in/out */ ! 668: { ! 669: register unsigned long diff = *diffp; ! 670: register struct nlist *symp = 0; ! 671: struct nlist *sp, *ep, *cp; ! 672: boolean_t first_pass = FALSE; ! 673: ! 674: sp = (struct nlist *)symtab->start; ! 675: ep = (struct nlist *)symtab->end; ! 676: ! 677: if (symtab->sorted) { ! 678: struct nlist target; ! 679: ! 680: target.n_value = off; ! 681: target.n_un.n_name = (char *) 0; ! 682: target.n_other = (char) 0; ! 683: db_qsort_limit_search((char *) &target, (char **) &sp, (char **) &ep, ! 684: sizeof (struct nlist), aout_db_compare_symbols); ! 685: first_pass = TRUE; ! 686: } ! 687: ! 688: try_again: ! 689: for (cp = ep-1; cp >= sp; cp--) { ! 690: if (cp->n_un.n_name == 0) ! 691: continue; ! 692: if ((cp->n_type & N_STAB) != 0) ! 693: continue; ! 694: if (strategy == DB_STGY_XTRN && (cp->n_type & N_EXT) == 0) ! 695: continue; ! 696: if (off >= cp->n_value) { ! 697: if (off - cp->n_value < diff) { ! 698: diff = off - cp->n_value; ! 699: symp = cp; ! 700: if (diff == 0 && (cp->n_type & N_EXT)) ! 701: break; ! 702: } ! 703: else if (off - cp->n_value == diff) { ! 704: if (symp == 0) ! 705: symp = cp; ! 706: else if ((symp->n_type & N_EXT) == 0 && ! 707: (cp->n_type & N_EXT) != 0) ! 708: symp = cp; /* pick the external symbol */ ! 709: } ! 710: } ! 711: } ! 712: if (symp == 0) { ! 713: if (first_pass) { ! 714: first_pass = FALSE; ! 715: sp = (struct nlist *) symtab->start; ! 716: goto try_again; ! 717: } ! 718: *diffp = off; ! 719: } ! 720: else { ! 721: *diffp = diff; ! 722: } ! 723: return ((db_sym_t)symp); ! 724: } ! 725: ! 726: /* ! 727: * Return the name and value for a symbol. ! 728: */ ! 729: void ! 730: aout_db_symbol_values( ! 731: db_sym_t sym, ! 732: char **namep, ! 733: db_expr_t *valuep) ! 734: { ! 735: register struct nlist *sp; ! 736: ! 737: sp = (struct nlist *)sym; ! 738: if (namep) ! 739: *namep = sp->n_un.n_name; ! 740: if (valuep) ! 741: *valuep = sp->n_value; ! 742: } ! 743: ! 744: #define X_DB_MAX_DIFF 8 /* maximum allowable diff at the end of line */ ! 745: extern int db_search_maxoff; /* maximum acceptable offset */ ! 746: ! 747: /* ! 748: * search symbol by value ! 749: */ ! 750: db_sym_t ! 751: aout_db_search_by_addr( ! 752: db_symtab_t *stab, ! 753: db_addr_t addr, ! 754: char **file, ! 755: char **func, ! 756: int *line, ! 757: db_expr_t *diff, ! 758: int *args) ! 759: { ! 760: struct nlist *sp, *cp; ! 761: register struct nlist *line_sp, *func_sp, *file_sp, *line_func; ! 762: unsigned long func_diff, line_diff; ! 763: boolean_t found_line = FALSE; ! 764: struct nlist *ep = (struct nlist *)stab->end; ! 765: boolean_t first_pass = FALSE; ! 766: ! 767: /* ! 768: * 92-May-16 ! 769: * Added init of these two... not sure if it's correct, but ! 770: * can't be worse than random values.... -- [email protected] ! 771: */ ! 772: func_diff = line_diff = /*HUGE*/0x0fffffff; ! 773: ! 774: line_sp = func_sp = file_sp = line_func = 0; ! 775: *file = *func = 0; ! 776: *line = 0; ! 777: *args = -1; ! 778: ! 779: sp = (struct nlist *)stab->start; ! 780: if (stab->sorted) { ! 781: struct nlist target; ! 782: ! 783: target.n_value = addr; ! 784: target.n_un.n_name = (char *) 0; ! 785: target.n_other = (char) 0; ! 786: db_qsort_limit_search((char *) &target, (char **) &sp, ! 787: (char **) &ep, sizeof (struct nlist), ! 788: aout_db_compare_symbols); ! 789: first_pass = TRUE; ! 790: } ! 791: ! 792: for (cp = sp; cp < ep; cp++) { ! 793: switch(cp->n_type) { ! 794: case N_SLINE: ! 795: if (cp->n_value <= addr) { ! 796: if (line_sp == 0 || line_diff >= addr - cp->n_value) { ! 797: if (line_func) ! 798: line_func = 0; ! 799: line_sp = cp; ! 800: line_diff = addr - cp->n_value; ! 801: } ! 802: } ! 803: if (cp->n_value >= addr && line_sp) ! 804: found_line = TRUE; ! 805: continue; ! 806: case N_FUN: ! 807: if ((found_line || (line_sp && line_diff < X_DB_MAX_DIFF)) ! 808: && line_func == 0) ! 809: line_func = cp; ! 810: continue; ! 811: case N_SO: ! 812: if (cp->n_value > addr) ! 813: continue; ! 814: if (file_sp == 0 || file_sp->n_value <= cp->n_value) ! 815: file_sp = cp; ! 816: continue; ! 817: case N_TEXT: ! 818: if (aout_db_is_filename(cp->n_un.n_name)) { ! 819: if (cp->n_value > addr) ! 820: continue; ! 821: if (file_sp == 0 || file_sp->n_value <= cp->n_value) ! 822: file_sp = cp; ! 823: } else if (cp->n_value <= addr && ! 824: (func_sp == 0 || func_diff > addr - cp->n_value)) { ! 825: func_sp = cp; ! 826: func_diff = addr - cp->n_value; ! 827: } ! 828: continue; ! 829: case N_TEXT|N_EXT: ! 830: if (cp->n_value <= addr && ! 831: (func_sp == 0 || func_diff >= addr - cp->n_value)) { ! 832: func_sp = cp; ! 833: func_diff = addr - cp->n_value; ! 834: if (func_diff == 0 && file_sp && func_sp && line_sp == 0) ! 835: break; ! 836: } ! 837: default: ! 838: if (stab->sorted) { ! 839: if ((cp->n_value > addr) && ! 840: (cp->n_value - addr > db_search_maxoff)) ! 841: break; ! 842: } ! 843: continue; ! 844: } ! 845: break; ! 846: } ! 847: if (first_pass && (!file_sp || !line_sp || !func_sp)) { ! 848: first_pass = FALSE; ! 849: cp = sp; ! 850: sp = (struct nlist *)stab->start; ! 851: for (; cp >= sp; cp--) { ! 852: switch(cp->n_type) { ! 853: case N_SLINE: ! 854: if (line_sp) ! 855: found_line = TRUE; ! 856: continue; ! 857: case N_FUN: ! 858: if ((found_line || (line_sp && line_diff < X_DB_MAX_DIFF)) ! 859: && line_func == 0) ! 860: line_func = cp; ! 861: continue; ! 862: case N_SO: ! 863: if (file_sp == 0) ! 864: file_sp = cp; ! 865: continue; ! 866: case N_TEXT: ! 867: if (aout_db_is_filename(cp->n_un.n_name)) { ! 868: if (file_sp == 0) ! 869: file_sp = cp; ! 870: } else if (func_sp == 0) { ! 871: func_sp = cp; ! 872: func_diff = addr - cp->n_value; ! 873: } ! 874: continue; ! 875: case N_TEXT|N_EXT: ! 876: if (func_sp == 0) { ! 877: func_sp = cp; ! 878: func_diff = addr - cp->n_value; ! 879: if (func_diff == 0 && file_sp && func_sp ! 880: && line_sp == 0) ! 881: break; ! 882: } ! 883: default: ! 884: if (line_sp && file_sp && ! 885: addr - cp->n_value > db_search_maxoff) ! 886: break; ! 887: continue; ! 888: } ! 889: break; ! 890: } ! 891: } ! 892: #if 0 ! 893: /* ! 894: * XXX - [email protected] ! 895: * I don't know if that code is useful to something, but it makes the -gline ! 896: * option of gcc useless. ! 897: */ ! 898: if (line_sp) { ! 899: if (line_func == 0 || func_sp == 0 ! 900: || line_func->n_value != func_sp->n_value) ! 901: line_sp = 0; ! 902: } ! 903: #else ! 904: if (line_sp && !found_line) { ! 905: line_sp = 0; ! 906: } ! 907: #endif ! 908: *diff = 0; ! 909: if (file_sp) { ! 910: *diff = addr - file_sp->n_value; ! 911: *file = file_sp->n_un.n_name; ! 912: } ! 913: if (line_sp) { ! 914: *diff = addr - line_sp->n_value; ! 915: *line = line_sp->n_desc; ! 916: } ! 917: if (func_sp) { ! 918: *diff = addr - func_sp->n_value; ! 919: *func = (func_sp->n_un.n_name[0] == '_')? ! 920: func_sp->n_un.n_name + 1: func_sp->n_un.n_name; ! 921: if (line_func && (line_func->n_desc & 0x4000)) ! 922: *args = line_func->n_desc & 0x3ff; ! 923: } ! 924: return((db_sym_t) func_sp); ! 925: } ! 926: ! 927: /* ! 928: * Find filename and lineno within, given the current pc. ! 929: */ ! 930: boolean_t ! 931: aout_db_line_at_pc( ! 932: db_symtab_t *stab, ! 933: db_sym_t sym, ! 934: char **file, ! 935: int *line, ! 936: db_expr_t pc) ! 937: { ! 938: char *func; ! 939: db_expr_t diff; ! 940: boolean_t found; ! 941: int args; ! 942: ! 943: found = (aout_db_search_by_addr(stab, (unsigned)pc, file, &func, line, ! 944: &diff, &args) ! 945: != DB_SYM_NULL); ! 946: return(found && func && *file); ! 947: } ! 948: ! 949: /* ! 950: * Initialization routine for a.out files. ! 951: */ ! 952: void ! 953: aout_db_init(void) ! 954: { ! 955: #ifndef __MACHO__ ! 956: extern vm_offset_t kern_sym_start; ! 957: extern vm_size_t kern_sym_size; ! 958: #else ! 959: extern struct mach_header _mh_execute_header; ! 960: #endif ! 961: ! 962: #ifndef __MACHO__ ! 963: if (kern_sym_size != 0) ! 964: aout_db_sym_init((char *) kern_sym_start, ! 965: (char *)(kern_sym_start + kern_sym_size), ! 966: "mach", ! 967: (char *)0); ! 968: #else ! 969: aout_db_sym_init((char *) &_mh_execute_header, ! 970: (char *)0, "mach", (char *)0); ! 971: #endif ! 972: } ! 973: ! 974: #endif /* DB_NO_AOUT */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.