osfmk/ddb/db_aout.c

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