4.3BSD - /usr/src/old/sdb/symt.c

   1: static  char sccsid[] = "@(#)symt.c 4.3 8/17/82";
   2: #include "head.h"
   3: #include <a.out.h>
   4: #include <stab.h>
   5: 
   6: #ifndef STABTYPES
   7: #define STABTYPES N_STAB
   8: #endif
   9: #include <sys/stat.h>
  10: 
  11: struct user u;
  12: int compar();
  13: char *symfil;
  14: 
  15: #ifdef FLEXNAMES
  16: 
  17: struct  nlist *symtab;
  18: char    nullname[] = {0,0,0,0,0,0,0,0,0};   /* a few 0 bytes */
  19: off_t   stoff;
  20: 
  21: stread(buff, nbytes)
  22: struct nlist *buff;
  23: int nbytes;
  24: {
  25:     register int from = stoff;
  26: 
  27:     stoff += nbytes;
  28:     if (stoff >= gstart)
  29:         return (-1);
  30:     if (nbytes < 0) {
  31:         from = stoff;
  32:         buff--;
  33:     }
  34:     from = (from - ststart);
  35:     *buff = symtab[from/sizeof (struct nlist)];
  36:     return (sizeof (struct nlist));
  37: }
  38: 
  39: stseek(off, rel)
  40: long off;
  41: {
  42: 
  43:     if (rel == 1)
  44:         stoff += off;
  45:     else
  46:         stoff = off;
  47: }
  48: #define bread(a,b,c)    stread(b,c)
  49: #define blseek(a,b,c)   stseek(b,c)
  50: #endif
  51: 
  52: /* initialize file and procedure tables */
  53: initfp() {
  54:     struct nlist stentry;
  55:     register struct proct *procp;
  56:     register struct filet *filep;
  57:     struct stat stbuf;
  58: 
  59:     long soffset;
  60:     int i, gflag = 0;
  61:     u_char class;
  62:     register char *p, *q;
  63: 
  64: #ifdef FLEXNAMES
  65:     register struct nlist *sp;
  66:     int malformed = 0;
  67:     lseek(txtmap.ufd, gstart, 0);
  68:     if (read(txtmap.ufd, &ssiz, sizeof(ssiz)) != sizeof (ssiz)) {
  69:         printf("%s: no string table (old format?)\n", symfil);
  70:         exit(1);
  71:     }
  72:     strtab = (char *)malloc(ssiz);
  73:     if (strtab == 0) {
  74:         printf("no room for %d bytes of string table\n", ssiz);
  75:         exit(1);
  76:     }
  77:     ssiz -= sizeof (ssiz);
  78:     if (read(txtmap.ufd, strtab+sizeof (ssiz), ssiz) != ssiz) {
  79:         printf("%s: error reading string table\n", symfil);
  80:         exit(1);
  81:     }
  82:     i = gstart - ststart;
  83:     symtab = (struct nlist *)malloc(i);
  84:     if (symtab == 0) {
  85:         printf("no room for %d bytes of symbol table\n", i);
  86:         exit(1);
  87:     }
  88:     lseek(txtmap.ufd, ststart, 0);
  89:     if (read(txtmap.ufd, symtab, i) != i) {
  90:         printf("%s: error reading symbol table\n", symfil);
  91:         exit(1);
  92:     }
  93:     for (sp = &symtab[i/sizeof (struct nlist)]; --sp >= symtab; )
  94:     if (sp->n_un.n_strx != 0) {
  95:         if (sp->n_un.n_strx < sizeof (ssiz) || sp->n_un.n_strx >= ssiz) {
  96:             if (malformed == 0) {
  97:                 printf("danger: mangled symbol table\n");
  98:                 malformed = 1;
  99:             }
 100:             sp->n_un.n_name = nullname;
 101:         } else
 102:             sp->n_un.n_name = strtab + sp->n_un.n_strx;
 103:     } else
 104:         sp->n_un.n_name = nullname;
 105: #endif
 106: #ifndef VMUNIX
 107:     sbuf.fd = txtmap.ufd;
 108: #endif
 109:     firstdata = MAXPOS;
 110:     soffset = ststart;
 111:     blseek(&sbuf,ststart,0);
 112:     filep = files = badfile = (struct filet *) sbrk(sizeof filep[0]);
 113:     procp = procs = badproc = (struct proct *) sbrk(sizeof procp[0]);
 114: 
 115:     for(;;) {
 116:         if (bread(&sbuf, &stentry, sizeof stentry) <
 117:                 sizeof stentry) break;
 118:         class = stentry.n_type & STABMASK;
 119:         switch (class & STABMASK) {
 120:         case N_SO:
 121:         case N_SOL:
 122:             gflag++;
 123:             if (filep == badfile) {
 124:                 p = sbrk(FILEINCR*sizeof filep[0]);
 125:                 if (p < 0) {
 126:                     perror("sdb");
 127:                     exit(4);
 128:                 }
 129:                 q = p + FILEINCR*sizeof filep[0];
 130:                 while (p > (char *) procs)
 131:                     *--q = *--p;
 132:                 badfile += FILEINCR;
 133:                 procp = (struct proct *)
 134:                     ((char *) procp +
 135:                         FILEINCR*sizeof filep[0]);
 136:                 procs = (struct proct *)
 137:                     ((char *) procs +
 138:                         FILEINCR*sizeof filep[0]);
 139:                 badproc = (struct proct *)
 140:                     ((char *)badproc +
 141:                         FILEINCR*sizeof filep[0]);
 142:             }
 143:             filep->faddr = stentry.n_value;
 144:             filep->lineflag = (class == N_SOL);
 145:             filep->stf_offset = soffset;
 146: #ifndef FLEXNAMES
 147:             p = filep->sfilename;
 148:             for (;;) {
 149:                 for (i=0; i<8; i++) *p++ = stentry.n_un.n_name[i];
 150:                 if (*(p-1) == '\0') break;
 151:                 if (bread(&sbuf, &stentry, sizeof stentry)
 152:                         < sizeof stentry)
 153:                     error("Bad N_SO entry (1)");
 154:                 if ((stentry.n_type & STABMASK) != class)
 155:                     error("Bad N_SO entry (2)");
 156:                 soffset += sizeof stentry;
 157:             }
 158: #else
 159:             filep->sfilename = stentry.n_un.n_name;
 160: #endif
 161:             q = filep->sfilename;
 162:             for (p=fp; *q; *p++ = *q++) ;
 163:             *p = 0;
 164:             if (stat(filework, &stbuf) == -1)
 165:                 printf("Warning: `%s' not found\n",
 166:                     filep->sfilename);
 167:             else if (stbuf.st_mtime > symtime)
 168:                 printf("Warning: `%s' newer than `%s'\n",
 169:                     filep->sfilename,
 170:                     symfil);
 171:             filep++;
 172:             break;
 173: 
 174:         case N_TEXT:
 175:             if (stentry.n_un.n_name[0] != '_') break;
 176:         case N_FUN:
 177:         case N_ENTRY:
 178:             if (procp == badproc) {
 179:                 if (sbrk(PROCINCR*sizeof procp[0]) < 0) {
 180:                     perror("sdb");
 181:                     exit(4);
 182:                 }
 183:                 badproc += PROCINCR;
 184:             }
 185: #ifndef FLEXNAMES
 186:             for(i=0; i<8; i++)
 187:                 procp->pname[i] = stentry.n_un.n_name[i];
 188: #else
 189:             procp->pname = stentry.n_un.n_name;
 190: #endif
 191:             procp->paddr = stentry.n_value;
 192:             procp->st_offset = soffset;
 193:             procp->sfptr = (class != N_TEXT) ? filep - 1 : badfile;
 194:             procp->lineno = (class != N_TEXT) ? stentry.n_desc : 0;
 195:             procp->entrypt = (class & STABMASK) == N_ENTRY;
 196:             procp++;
 197:             break;
 198:         }
 199:         if (stentry.n_type & N_EXT) {
 200:             if (!extstart)
 201:                 extstart = soffset;
 202:             if (stentry.n_type == N_DATA | N_EXT ||
 203:                     stentry.n_type == N_BSS | N_EXT ||
 204:                     stentry.n_value < firstdata)
 205:                 firstdata = stentry.n_value;
 206:         }
 207:         soffset += sizeof stentry;
 208:     }
 209:     qsort(procs, procp-procs, sizeof procs[0], compar);
 210:     badproc->st_offset = badfile->stf_offset = soffset;
 211:     badproc->sfptr = procp->sfptr = badfile;
 212: #ifndef FLEXNAMES
 213:     badproc->pname[0] = badfile->sfilename[0]=
 214:         procp->pname[0] = filep->sfilename[0] = '\0';
 215: #else
 216:     badproc->pname = badfile->sfilename=
 217:         procp->pname = filep->sfilename = nullname;
 218: #endif
 219: 
 220:     if (!gflag)
 221:         printf("Warning: `%s' not compiled with -g\n", symfil);
 222:     setcur(1);
 223: }
 224: 
 225: /* returns current procedure from state (curfile, fline) */
 226: struct proct *
 227: curproc() {
 228:     register ADDR addr;
 229: 
 230:     addr = getaddr("", fline ? fline : 1);
 231:     if (addr == -1) return(badproc);
 232:     return(adrtoprocp(addr));
 233: 
 234: }
 235: 
 236: /* returns procedure s, uses curproc() if s == NULL */
 237: 
 238: struct proct *
 239: findproc(s)
 240: char *s; {
 241:     register struct proct *p, *altproc;
 242: 
 243:     if (s[0] == '\0') return(curproc());
 244:     altproc = badproc;
 245: 
 246:     for (p=procs; p->pname[0]; p++) {
 247:         if (eqpat(s, p->pname)) return(p);
 248:         if (p->pname[0] == '_' && eqpatr(s, p->pname+1, 1))
 249:             altproc = p;
 250:     }
 251:     return(altproc);
 252: }
 253: 
 254: /* returns file s containing filename */
 255: struct filet *
 256: findfile(s)
 257: char *s; {
 258:     register struct filet *f;
 259:     if (s == 0 || *s == 0)
 260:         return(files);      /* start at beginning if no cur file */
 261:     for (f=files; f->sfilename[0]; f++) {
 262:         if (eqpat(f->sfilename, s)) {
 263:             for( ; f->lineflag; f--) ;
 264:             if (f < files) error("Bad file array");
 265:             return(f);
 266:         }
 267:     }
 268:     return(f);
 269: }
 270: 
 271: /*
 272:  * slookup():
 273:  * looks up variable matching pat starting at (offset + sizeof stentry)
 274:  * in a.out, searching backwards,
 275:  * ignoring nested blocks to beginning to procedure.
 276:  * Returns its offset and symbol table entries decoded in sl_*
 277:  *
 278:  * If comblk == "*" then match both within and outside common blocks,
 279:  * if comblk == ""  then match only outside common blocks,
 280:  *                  else match only within comblk.
 281:  */
 282: 
 283: long
 284: slookup(pat, poffset, stelt)
 285: long poffset; char *pat; {
 286:     slookinit();
 287:     slooknext(pat, poffset, stelt, "*");
 288: }
 289: 
 290: int clevel, level, fnameflag, comfound, incomm;
 291: 
 292: slookinit() {
 293:     clevel = level = fnameflag = comfound = incomm = 0;
 294: }
 295: 
 296: long
 297: slooknext(pat, poffset, stelt, comblk)
 298: long poffset; char *pat, *comblk; {
 299:     register int i;
 300:     register long offset;
 301:     char    *q;
 302:     u_char  class;
 303:     struct nlist stentry;
 304:     struct proct *procp, *p;
 305: 
 306:     offset = poffset + sizeof stentry;
 307:     if (debug) printf("slookup(%s,%d)\n",pat,offset);
 308:     blseek(&sbuf, offset, 0);
 309: 
 310:     for (;;) {
 311:         offset -= sizeof stentry;
 312:         if (offset < ststart) break;
 313:         if (bread(&sbuf, &stentry+1, -sizeof stentry)
 314:             < sizeof stentry) break;
 315:         class = stentry.n_type & STABMASK;
 316:         switch (class & STABMASK) {
 317:         case 0:
 318:             break;
 319:         case N_FUN:
 320:             return(-1);
 321:         case N_RBRAC:
 322:             level++;
 323:             break;
 324:         case N_LBRAC:
 325:             level--;
 326:             break;
 327:         case N_ECOMM:
 328:             i = 0;
 329: #ifndef FLEXNAMES
 330:             for (q = &stentry.n_un.n_name[7]; q>=stentry.n_un.n_name; q--) {
 331:                 if (*q == '_') {
 332:                     *q = '\0';
 333:                     i++;
 334:                     break;
 335:                 }
 336:             }
 337: #else
 338:             for (q = stentry.n_un.n_name; *q; q++)
 339:                 continue;
 340:             if (*--q == '_')
 341:                 *q = 0, i++;
 342: #endif
 343:             if (eqpat(comblk, stentry.n_un.n_name))
 344:                 comfound = 1;
 345:             if (i)
 346:                 *q = '_';
 347:             incomm = 1;
 348:         case N_ECOML:
 349:             clevel++;
 350:             break;
 351:         case N_BCOMM:
 352:             comfound = incomm = 0;
 353:             clevel--;
 354:             break;
 355:         case N_FNAME:
 356:             if (fnameflag)
 357:                 break;
 358:             procp = findproc(stentry.n_un.n_name);
 359:             for (p=procs; p->pname[0]; p++) {
 360:                 if (p->entrypt == 0 &&
 361:                     p->st_offset > procp->st_offset &&
 362:                     p->st_offset < offset)
 363:                         offset = p->st_offset;
 364:             }
 365:             clevel = level = 0;
 366:             fnameflag++;
 367:             blseek(&sbuf, offset, 0);
 368:             break;
 369:         default:
 370:             if (level <= 0  &&  eqpat(pat, stentry.n_un.n_name) &&
 371:                 stentry.n_un.n_name[0] && class & STABTYPES &&
 372:                 (eqstr("*", comblk) ||
 373:                  (comblk[0] == '\0' && incomm == 0) ||
 374:                  comfound) &&
 375:                 (stelt == (class == N_SSYM))) {
 376:                 if (class == N_LENG) {
 377:                     sl_size = stentry.n_value;
 378:                     offset -= sizeof stentry;
 379:                     bread(&sbuf, &stentry+1,
 380:                             -sizeof stentry);
 381:                     if (stentry.n_type&~N_EXT == N_BSS) {
 382:                         bread(&sbuf, &stentry+1,
 383:                             -sizeof stentry);
 384:                         offset -= sizeof stentry;
 385:                     }
 386:                 }
 387:                 else sl_size = 0;
 388:                 sl_class = stentry.n_type & STABMASK;
 389:                 sl_type = stentry.n_desc;
 390:                 sl_addr = stentry.n_value;
 391: #ifndef FLEXNAMES
 392:                 for (i=0; i<8; i++) sl_name[i] =
 393:                         stentry.n_un.n_name[i];
 394: #else
 395:                 sl_name = stentry.n_un.n_name;
 396: #endif
 397:                 if (clevel != 0) docomm(offset);
 398:                 return(offset - sizeof stentry);
 399:             }
 400:         }
 401:     }
 402:     return(-1);
 403: }
 404: 
 405: /*
 406:  * Look up global variable matching pat starting at (filestart+sizeof stentry)
 407:  * Return its offset and symbol table entries decoded in sl_*
 408:  */
 409: long
 410: globallookup(pat, filestart, stelt)
 411: char *pat; long filestart; {
 412:     register int offset, i;
 413:     struct nlist stentry;
 414:     int clevel;
 415:     u_char  class;
 416: 
 417:     if (debug) printf("globallookup(%s,%d)\n", pat,filestart);
 418:     blseek(&sbuf, filestart, 0);
 419:     offset = filestart - sizeof stentry;
 420:     clevel = 0;
 421:     do {
 422:         if (bread(&sbuf, &stentry, sizeof stentry) <
 423:                 sizeof stentry) return(-1);
 424:         offset += sizeof stentry;
 425:     } while ((stentry.n_type & STABMASK) == N_SO);
 426:     for (;;) {
 427:         class = stentry.n_type & STABMASK;
 428:         switch (class & STABMASK) {
 429:         case N_SO:
 430:             return(-1);
 431:         case N_ECOMM:
 432:             clevel--;
 433:             break;
 434:         case N_BCOMM:
 435:             clevel++;
 436:             break;
 437:         default:
 438:         if (eqpat(pat, stentry.n_un.n_name)
 439:                 && stentry.n_un.n_name[0] && class & STABTYPES) {
 440:             sl_class = stentry.n_type & STABMASK;
 441:             if (sl_class != N_GSYM && sl_class != N_SSYM &&
 442:                 sl_class != N_STSYM && sl_class != N_LCSYM) goto g1;
 443:             if (stelt != (sl_class == N_SSYM)) goto g1;
 444:             sl_size = 0;
 445:             sl_type = stentry.n_desc;
 446:             sl_addr = stentry.n_value;
 447: #ifndef FLEXNAMES
 448:             for (i=0; i<8; i++) sl_name[i] = stentry.n_un.n_name[i];
 449: #else
 450:             sl_name = stentry.n_un.n_name;
 451: #endif
 452:             if (clevel != 0) docomm(offset);
 453:             goto g2;
 454:         }
 455:         }
 456: g1:     if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry)
 457:             return(-1);
 458:         offset += sizeof stentry;
 459:     }
 460: g2: bread(&sbuf, &stentry, sizeof stentry);
 461:     if (stentry.n_type&~N_EXT==N_BSS) {
 462:         bread(&sbuf, &stentry, sizeof stentry);
 463:         offset += sizeof stentry;
 464:     }
 465:     if (((stentry.n_type & STABMASK) == N_LENG) &&
 466:             (eqpat(sl_name, stentry.n_un.n_name)))
 467:         sl_size = stentry.n_value;
 468: 
 469:     if (sl_class == N_GSYM && (clevel == 0)) {
 470:         blseek(&sbuf, extstart, 0);
 471:         for(;;) {
 472:             if (bread(&sbuf, &stentry, sizeof stentry)
 473:                     < sizeof stentry)
 474:                 return(-1);
 475:             if (stentry.n_un.n_name[0] != '_') continue;
 476:             if (eqpatr(sl_name, stentry.n_un.n_name+1, 1)) {
 477:                 sl_addr = stentry.n_value;
 478:                 break;
 479:             }
 480:         }
 481:     }
 482:     return(offset + sizeof stentry);
 483: }
 484: 
 485: /* core address to procedure (pointer to proc array) */
 486: struct proct *
 487: adrtoprocp(addr)
 488: ADDR addr; {
 489:     register struct proct *procp, *lastproc;
 490:     lastproc = badproc;
 491:     for (procp=procs; procp->pname[0]; procp++) {
 492:         if (procp->paddr > addr) break;
 493:         if (procp->entrypt == 0)
 494:             lastproc = procp;
 495:     }
 496:     return (lastproc);
 497: }
 498: 
 499: 
 500: /* core address to file (pointer to file array) */
 501: struct filet *
 502: adrtofilep(addr)
 503: ADDR addr; {
 504:     register struct filet *filep;
 505:     for (filep=files; filep->sfilename[0]; filep++) {
 506:         if (filep->faddr > addr) break;
 507:     }
 508:     return (filep != files ? filep-1 : badfile);
 509: }
 510: 
 511: /*
 512:  * core address to linenumber
 513:  *  Sets external exactaddr to addr if addr is NOT the first instruction
 514:  * of a line, set to -1 otherwise.
 515:  *  Sets external lnfaddr to address of first statement in line.
 516:  */
 517: long lastoffset;
 518: 
 519: adrtolineno(addr)
 520: ADDR addr; {
 521:     register int lineno;
 522:     long offset;
 523:     struct nlist stentry;
 524: 
 525:     exactaddr = addr;
 526:     lineno = lastoffset = -1;
 527:     offset = adrtoprocp(addr)->st_offset;
 528:     blseek(&sbuf, offset, 0);
 529:     for (;;) {
 530:         if (bread(&sbuf, &stentry, sizeof stentry)
 531:                 < sizeof stentry) break;
 532:         if (stentry.n_type == N_SO)
 533:             break;
 534:         if (stentry.n_type == N_SLINE) {
 535:             if (stentry.n_value > addr)
 536:                 break;
 537:             lastoffset = offset;
 538:             lineno = stentry.n_desc;
 539:             lnfaddr = stentry.n_value;
 540:             if (stentry.n_value == addr)
 541:                 exactaddr = -1;
 542:         }
 543:         offset += sizeof stentry;
 544:     }
 545:     return (lineno);
 546: }
 547: 
 548: 
 549: /* address to a.out offset */
 550: long
 551: adrtostoffset(addr)
 552: ADDR addr; {
 553:     adrtolineno(addr);
 554:     return(lastoffset);
 555: }
 556: 
 557: 
 558: /*
 559:  * Set (curfile, lineno) from core image.
 560:  * Returns 1 if there is a core image, 0 otherwise.
 561:  *
 562:  * Print the current line iff verbose is set.
 563:  */
 564: setcur(verbose) {
 565:     register struct proct *procp;
 566: 
 567:     dot = *(ADDR *) (((ADDR) &u) + PC);
 568: 
 569:     if (dot == 0) {
 570:         printf("No core image\n");
 571:         goto setmain;
 572:     }
 573:     procp = adrtoprocp(dot);
 574:     if ((procp->sfptr) != badfile) {
 575:         finit(adrtofilep(procp->paddr)->sfilename);
 576:         ffind(adrtolineno(dot));
 577:         if (verbose) {
 578:             if (exactaddr != -1)
 579:                 printf("0x%x in ", exactaddr);
 580: #ifndef FLEXNAMES
 581:             printf("%.8s:", procp->pname);
 582: #else
 583:             printf("%s:", procp->pname);
 584: #endif
 585:             fprint();
 586:         }
 587:         return(1);
 588:     }
 589:     if (verbose) {
 590:         if (procp->pname[0] == '_')
 591: #ifndef FLEXNAMES
 592:             printf("%.7s: address 0x%x\n", procp->pname+1, dot);
 593: #else
 594:             printf("%s: address 0x%x\n", procp->pname+1, dot);
 595: #endif
 596:         else
 597: #ifndef FLEXNAMES
 598:             printf("%.8s: address %d\n", procp->pname, dot);
 599: #else
 600:             printf("%s: address %d\n", procp->pname, dot);
 601: #endif
 602:     }
 603: 
 604: setmain:
 605:     procp = findproc("MAIN_");
 606:     if ((procp->pname[0] != 'M') || (procp->sfptr == badfile)) {
 607:         procp = findproc("main");
 608:         if ((procp->pname[0] != 'm') || (procp->sfptr == badfile)) {
 609:             /* printf("main not compiled with debug flag\n"); */
 610:             return(0);
 611:         }
 612:     }
 613:     finit(procp->sfptr->sfilename);
 614:     ffind(procp->lineno);
 615:     return(0);
 616: }
 617: 
 618: compar(a, b)
 619: struct proct *a, *b; {
 620:     if (a->paddr == b->paddr) {
 621:         if (a->pname[0] == '_') return(-1);
 622:         if (b->pname[0] == '_') return(1);
 623:         return(0);
 624:     }
 625:     return(a->paddr < b->paddr ? -1 : 1);
 626: }
 627: 
 628: /* gets offset of file or procedure named s */
 629: nametooffset(s)
 630: char *s; {
 631:     register struct filet *f;
 632:     register struct proct *p;
 633: 
 634:     if (*s == '\0')
 635:         return(-1);
 636:     if (eqany('.', s)) {
 637:         f = findfile(s);
 638:         return(f->sfilename[0] ? f->stf_offset : -1);
 639:     }
 640:     p = findproc(s);
 641:     return(p->pname[0] ? p->st_offset : -1);
 642: }
 643: 
 644: /* returns s if its a filename, its file otherwise */
 645: char *
 646: nametofile(s)
 647: char *s; {
 648:     register struct proct *p;
 649: 
 650:     if (eqany('.', s)) {
 651:         return(s);
 652:     }
 653:     p = findproc(s);
 654:     return(adrtofilep(p->paddr)->sfilename);
 655: }
 656: 
 657: 
 658: /* line number to address, starting at offset in a.out */
 659: /* assumes that offset is within file */
 660: lntoaddr(lineno, offset, file)
 661: long offset; char *file; {
 662:     struct nlist stentry;
 663:     register int i, ignore = 0;
 664:     register int bestln=BIGNUM;
 665:     ADDR bestaddr;
 666:     char *p;
 667: 
 668:     blseek(&sbuf, offset, 0);
 669: 
 670:     do {
 671:         if (bread(&sbuf, &stentry, sizeof stentry) <
 672:                 sizeof stentry) return(-1);
 673:     } while ((stentry.n_type & STABMASK) == N_SO);
 674:     for (;;) {
 675:         switch(stentry.n_type & STABMASK) {
 676:         case N_SLINE:
 677:             if (!ignore) {
 678:                 if (stentry.n_desc == lineno)
 679:                     return(stentry.n_value);
 680:                 if (stentry.n_desc > lineno &&
 681:                     stentry.n_desc < bestln) {
 682:                     bestln = stentry.n_desc;
 683:                     bestaddr = stentry.n_value;
 684:                 }
 685:             }
 686:             break;
 687: 
 688:         case N_SO:
 689:             goto ret;
 690: 
 691:         case N_SOL:
 692:             p = file;
 693: #ifndef FLEXNAMES
 694:             for (;;) {
 695:                 for (i=0; i<8; i++) {
 696:                     if (*p != stentry.n_un.n_name[i]) goto neq;
 697:                     if (*p++ == '\0') break;
 698:                 }
 699:                 if (stentry.n_un.n_name[7] == '\0')
 700:                     break;
 701:                 if (bread(&sbuf, &stentry, sizeof stentry)
 702:                         < sizeof stentry)
 703:                     error("Bad N_SO entry (1)");
 704:                 if ((stentry.n_type & STABMASK) != (u_char)N_SOL)
 705:                     error("Bad N_SO entry (2)");
 706:             }
 707: #else
 708:             if (strcmp(file, stentry.n_un.n_name))
 709:                 goto neq;
 710: #endif
 711:             ignore = 0;
 712:             break;
 713: 
 714: neq:            ignore++;
 715:             break;
 716:         }
 717:         if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry)
 718:             break;
 719:     }
 720: ret:    return(bestln == BIGNUM ? -1 : bestaddr);
 721: }
 722: 
 723: /* gets address of proc:number */
 724: getaddr(proc,integ)
 725: char *proc; {
 726:     register long offset;
 727:     register char *s, *f;
 728:     ADDR addr;
 729: 
 730:     s = proc[0] ? proc : curfile;
 731:     if (*s == '\0')
 732:         return(-1);
 733:     offset = nametooffset(s);
 734:     f = nametofile(s);
 735:     if (debug) printf("getaddr() computed offset %d", offset);
 736:     if (offset == -1) {
 737:         addr = extaddr(proc);
 738:         if (addr != -1) addr += 2;  /* MACHINE DEPENDENT */
 739:         if (debug) printf(" extaddr computed %d\n", addr);
 740:         return(addr);
 741:     }
 742:     if (integ)
 743:         addr = lntoaddr(integ, offset, s);
 744:     else {
 745:         ADDR oldaddr;
 746:         oldaddr = findproc(proc)->paddr + 2;  /* MACHINE DEPENDENT */
 747:         addr = lntoaddr(adrtolineno(addr)+1, offset, f);
 748:         if (addr == -1)
 749:             addr = oldaddr;
 750:     }
 751:     if (debug) printf(" and addr %d\n", addr);
 752:     if (addr == -1) return(-1);
 753:     return(addr);
 754: }
 755: 
 756: /* returns address of external */
 757: ADDR
 758: extaddr(name)
 759: char *name; {
 760:     struct nlist stentry;
 761:     blseek(&sbuf, extstart, 0);
 762: 
 763:     for (;;) {
 764:         if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry)
 765:             return(-1);
 766:         if (stentry.n_un.n_name[0] == '_' &&
 767:                 eqpatr(name, stentry.n_un.n_name+1, 1))
 768:             return(stentry.n_value);
 769:     }
 770: }
 771: 
 772: 
 773: /*
 774:  * Look up external data symbol matching pat starting at
 775:  *  (filestart+sizeof stentry)
 776:  * Return its address in sl_addr and name in sl_name.
 777:  */
 778: long
 779: extlookup(pat, filestart)
 780: char *pat; long filestart; {
 781:     register int offset, i;
 782:     struct nlist stentry;
 783: 
 784:     blseek(&sbuf, filestart, 0);
 785:     offset = filestart - sizeof stentry;
 786:     do {
 787:         if (bread(&sbuf, &stentry, sizeof stentry) <
 788:                 sizeof stentry) return(-1);
 789:         offset += sizeof stentry;
 790:     } while ((stentry.n_type & STABMASK) == N_SO);
 791:     for (;;) {
 792:         if (stentry.n_un.n_name[0] == '_' &&
 793:                 stentry.n_type == (N_DATA | N_EXT) &&
 794:                 eqpatr(pat, stentry.n_un.n_name+1, 1)) {
 795:             sl_addr = stentry.n_value;
 796: #ifndef FLEXNAMES
 797:             for (i=0; i<7; i++) sl_name[i] = stentry.n_un.n_name[i+1];
 798: #else
 799:             sl_name = stentry.n_un.n_name;
 800: #endif
 801:             return(offset + sizeof stentry);
 802:         }
 803: g1:     if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry)
 804:             return(-1);
 805:         offset += sizeof stentry;
 806:     }
 807: }
 808: 
 809: /* find enclosing common blocks and fix up addresses */
 810: docomm(offset)
 811: long offset; {
 812:     struct nlist stentry;
 813:     ADDR addr;
 814: 
 815:     for (;;) {
 816:         if (bread(&sbuf, &stentry, sizeof stentry) < sizeof stentry) {
 817:             error("Bad common block");
 818:             return;
 819:         }
 820:         sl_class = N_GSYM;
 821:         if ((stentry.n_type & STABMASK) == N_ECOMM) {
 822:             addr = extaddr(stentry.n_un.n_name);
 823:             if (addr == -1)
 824:                 error("Lost common block");
 825:             sl_addr +=addr;
 826:             blseek(&sbuf, offset, 0);
 827:             return;
 828:         }
 829:         if ((stentry.n_type & STABMASK) == N_ECOML) {
 830:             sl_addr += stentry.n_value;
 831:             blseek(&sbuf, offset, 0);
 832:             return;
 833:         }
 834:     }
 835: }
 836: 
 837: /* determine if class is that of a variable */
 838: char pctypes[] = {N_GSYM, N_STSYM, N_LCSYM, N_RSYM, N_SSYM, N_LSYM,
 839:             N_PSYM, 0};
 840: varclass(class)
 841: u_char class; {
 842:     char *p;
 843: 
 844:     for (p=pctypes; *p; p++) {
 845:         if (class == *p)
 846:             return(1);
 847:     }
 848:     return(0);
 849: }
 850: 
 851: /*
 852:  * address to external name
 853:  * returns difference between addr and address of external
 854:  * name returned in sl_name
 855:  */
 856: adrtoext(addr)
 857: ADDR addr; {
 858:     struct nlist stentry;
 859:     register int i, prevdiff = MAXPOS, diff;
 860: 
 861:     blseek(&sbuf, extstart, 0);
 862:     for (;;) {
 863:         if (bread(&sbuf, &stentry, sizeof stentry)
 864:                 < sizeof stentry)
 865:             return (prevdiff!=MAXPOS ? prevdiff : -1);
 866:         if (stentry.n_type == (N_DATA | N_EXT) ||
 867:             stentry.n_type == (N_BSS | N_EXT)) {
 868:             diff = addr - stentry.n_value;
 869:             if (diff >= 0 && diff < prevdiff) {
 870: #ifndef FLEXNAMES
 871:                 for (i=0; i<7; i++)
 872:                     sl_name[i] = stentry.n_un.n_name[i+1];
 873: #else
 874:                 sl_name = stentry.n_un.n_name;
 875: #endif
 876:                 if (diff == 0)
 877:                     return(0);
 878:                 prevdiff = diff;
 879:             }
 880:         }
 881:     }
 882: }
 883: 
 884: /*
 885:  * address to local name in procp
 886:  * returns difference between addr and address of local
 887:  * returned in sl_name
 888:  */
 889: adrtolocal(addr, procp)
 890: ADDR addr; struct proct *procp; {
 891:     struct nlist stentry;
 892:     register int i, prevdiff = MAXPOS, diff;
 893: 
 894:     blseek(&sbuf, procp->st_offset + sizeof stentry, 0);
 895:     for (;;) {
 896:         if (bread(&sbuf, &stentry, sizeof stentry)
 897:                 < sizeof stentry)
 898:             return(prevdiff!=MAXPOS ? prevdiff : -1);
 899:         if (stentry.n_type == N_FUN)
 900:             return(prevdiff!=MAXPOS ? prevdiff : -1);
 901:         if (stentry.n_type == N_LSYM) {
 902:             diff = addr - stentry.n_value;
 903:             if (diff >= 0 && diff < prevdiff) {
 904: #ifndef FLEXNAMES
 905:                 for (i=0; i<8; i++)
 906:                     sl_name[i] = stentry.n_un.n_name[i];
 907: #else
 908:                 sl_name = stentry.n_un.n_name;
 909: #endif
 910:                 if (diff == 0)
 911:                     return(0);
 912:                 prevdiff = diff;
 913:             }
 914:         }
 915:     }
 916: }
 917: 
 918: /*
 919:  * address to parameter name in procp
 920:  * returns difference between addr and address of local
 921:  * returned in sl_name
 922:  */
 923: adrtoparam(addr, procp)
 924: ADDR addr; struct proct *procp; {
 925:     struct nlist stentry;
 926:     register int i, prevdiff = MAXPOS, diff;
 927: 
 928:     blseek(&sbuf, procp->st_offset + sizeof stentry, 0);
 929:     for (;;) {
 930:         if (bread(&sbuf, &stentry, sizeof stentry)
 931:                 < sizeof stentry)
 932:             return(prevdiff!=MAXPOS ? prevdiff : -1);
 933:         if (stentry.n_type == N_FUN)
 934:             return(prevdiff!=MAXPOS ? prevdiff : -1);
 935:         if (stentry.n_type == N_PSYM) {
 936:             diff = addr - stentry.n_value;
 937:             if (diff >= 0 && diff < prevdiff) {
 938: #ifndef FLEXNAMES
 939:                 for (i=0; i<8; i++)
 940:                     sl_name[i] = stentry.n_un.n_name[i];
 941: #else
 942:                 sl_name = stentry.n_un.n_name;
 943: #endif
 944:                 if (diff == 0)
 945:                     return(0);
 946:                 prevdiff = diff;
 947:             }
 948:         }
 949:     }
 950: }
 951: 
 952: /*
 953:  * register number to register variable name in procp
 954:  * returned in sl_name
 955:  */
 956: adrtoregvar(regno, procp)
 957: ADDR regno; struct proct *procp; {
 958:     struct nlist stentry;
 959:     register int i;
 960: 
 961:     blseek(&sbuf, procp->st_offset + sizeof stentry, 0);
 962:     for (;;) {
 963:         if (bread(&sbuf, &stentry, sizeof stentry)
 964:                 < sizeof stentry) return(-1);
 965:         if (stentry.n_type == N_FUN)
 966:             return(-1);
 967:         if (stentry.n_type == N_RSYM) {
 968:             if (stentry.n_value == regno) {
 969: #ifndef FLEXNAMES
 970:                 for (i=0; i<8; i++)
 971:                     sl_name[i] = stentry.n_un.n_name[i];
 972: #else
 973:                 sl_name = stentry.n_un.n_name;
 974: #endif
 975:                 return(0);
 976:             }
 977:         }
 978:     }
 979: }
 980: 
 981: /* sets file map for M command */
 982: setmap(s)
 983: char *s; {
 984:     union {
 985:         MAP *m;
 986:         L_INT *mp;
 987:     } amap;
 988:     int starflag = 0;
 989: 
 990:     amap.mp = 0;
 991:     for (; *s; s++) {
 992:         switch (*s) {
 993:         case '/':
 994:             amap.m = &datmap;
 995:             break;
 996:         case '?':
 997:             amap.m = &txtmap;
 998:             break;
 999:         case '*':
1000:             starflag++;
1001:             break;
1002:         default:
1003:             goto sout;
1004:         }
1005:     }
1006: 
1007: sout:   if (amap.mp == 0) {
1008:         error("Map `?' or `/' must be specified");
1009:         return;
1010:     }
1011:     if (starflag)
1012:         amap.mp += 3;
1013:     for (; *s; s++) {
1014:         if (*s >= '0' && *s <= '9')
1015:             *(amap.mp)++ = readint(&s);
1016:     }
1017: }

Defined functions

Defined variables

Defined macros