![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to symt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / old / sdb|
Return to symt.c CVS log | Up to [CSRG BSD Unix] / 43BSD / old / sdb |
1.1 ! root 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: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.