![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sym.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Plan 9 NeXT] / lucent / sys / src / libmach|
Return to sym.c CVS log | Up to [Plan 9 NeXT] / lucent / sys / src / libmach |
1.1 ! root 1: #include <u.h> ! 2: #include <libc.h> ! 3: #include <bio.h> ! 4: #include <mach.h> ! 5: ! 6: #define HUGEINT 0x7fffffff ! 7: #define NNAME 20 /* a relic of the past */ ! 8: ! 9: typedef struct txtsym Txtsym; ! 10: typedef struct file File; ! 11: typedef struct hist Hist; ! 12: ! 13: struct txtsym { /* Text Symbol table */ ! 14: int n; /* number of local vars */ ! 15: Sym **locals; /* array of ptrs to autos */ ! 16: Sym *sym; /* function symbol entry */ ! 17: }; ! 18: ! 19: struct hist { /* Stack of include files & #line directives */ ! 20: char *name; /* Assumes names Null terminated in file */ ! 21: long line; /* line # where it was included */ ! 22: long offset; /* line # of #line directive */ ! 23: }; ! 24: ! 25: struct file { /* Per input file header to history stack */ ! 26: long addr; /* address of first text sym */ ! 27: union { ! 28: Txtsym *txt; /* first text symbol */ ! 29: Sym *sym; /* only during initilization */ ! 30: }; ! 31: int n; /* size of history stack */ ! 32: Hist *hist; /* history stack */ ! 33: }; ! 34: ! 35: static int debug = 0; ! 36: ! 37: static Sym **autos; /* Base of auto variables */ ! 38: static File *files; /* Base of file arena */ ! 39: static int fmax; /* largest file path index */ ! 40: static Sym **fnames; /* file names path component table */ ! 41: static Sym **globals; /* globals by addr table */ ! 42: static Hist *hist; /* base of history stack */ ! 43: static int isbuilt; /* internal table init flag */ ! 44: static long nauto; /* number of automatics */ ! 45: static long nfiles; /* number of files */ ! 46: static long nglob; /* number of globals */ ! 47: static long nhist; /* number of history stack entries */ ! 48: static long nsym; /* number of symbols */ ! 49: static int ntxt; /* number of text symbols */ ! 50: static uchar *pcline; /* start of pc-line state table */ ! 51: static uchar *pclineend; /* end of pc-line table */ ! 52: static uchar *spoff; /* start of pc-sp state table */ ! 53: static uchar *spoffend; /* end of pc-sp offset table */ ! 54: static Sym *symbols; /* symbol table */ ! 55: static Txtsym *txt; /* Base of text symbol table */ ! 56: static long txtstart; /* start of text segment */ ! 57: static long txtend; /* end of text segment */ ! 58: ! 59: static void cleansyms(void); ! 60: static int decodename(Biobuf*, Sym*); ! 61: static short *encfname(char *); ! 62: static Hist *fline(char *, int, long, Hist *); ! 63: static void fillsym(Sym *, Symbol *); ! 64: static int findglobal(char *, Symbol *); ! 65: static int findlocvar(Symbol *, char *, Symbol *); ! 66: static int findtext(char *, Symbol *); ! 67: static int hcomp(Hist *, short *); ! 68: static int hline(File *, short *, ulong *); ! 69: static void printhist(char *, Hist *, int); ! 70: static int buildtbls(void); ! 71: static int symcomp(void *, void *); ! 72: static int symerrmsg(int, char*); ! 73: static int txtcomp(void *, void *); ! 74: static int filecomp(void *, void *); ! 75: ! 76: /* ! 77: * initialize the symbol tables ! 78: */ ! 79: int ! 80: syminit(int fd, Fhdr *fp) ! 81: { ! 82: Sym *p; ! 83: int i, size; ! 84: Biobuf b; ! 85: ! 86: if(fp->symsz == 0) ! 87: return 0; ! 88: if(fp->type == FNONE) ! 89: return 0; ! 90: ! 91: cleansyms(); ! 92: textseg(fp->txtaddr, fp); ! 93: /* minimum symbol record size = 4+1+2 bytes */ ! 94: symbols = malloc((fp->symsz/(4+1+2)+1)*sizeof(Sym)); ! 95: if(symbols == 0) { ! 96: werrstr("can't malloc %d bytes", fp->symsz); ! 97: return -1; ! 98: } ! 99: ! 100: Binit(&b, fd, OREAD); ! 101: Bseek(&b, fp->symoff, 0); ! 102: nsym = 0; ! 103: size = 0; ! 104: for(p = symbols; size < fp->symsz; p++, nsym++) { ! 105: if(Bread(&b, &p->value, sizeof(p->value)) != sizeof(p->value)) ! 106: return symerrmsg(sizeof(p->value), "symbol"); ! 107: p->value = beswal(p->value); ! 108: if(Bread(&b, &p->type, sizeof(p->type)) != sizeof(p->type)) ! 109: return symerrmsg(sizeof(p->value), "symbol"); ! 110: ! 111: i = decodename(&b, p); ! 112: if(i < 0) ! 113: return -1; ! 114: size += i+sizeof(p->value)+sizeof(p->type); ! 115: ! 116: /* count global & auto vars, text symbols, and file names */ ! 117: switch (p->type) { ! 118: case 'l': ! 119: case 'L': ! 120: case 't': ! 121: case 'T': ! 122: ntxt++; ! 123: break; ! 124: case 'd': ! 125: case 'D': ! 126: case 'b': ! 127: case 'B': ! 128: nglob++; ! 129: break; ! 130: case 'f': ! 131: if(strcmp(p->name, ".frame") == 0) { ! 132: p->type = 'm'; ! 133: nauto++; ! 134: } ! 135: else if(p->value > fmax) ! 136: fmax = p->value; /* highest path index */ ! 137: break; ! 138: case 'a': ! 139: case 'p': ! 140: case 'm': ! 141: nauto++; ! 142: break; ! 143: case 'z': ! 144: if(p->value == 1) { /* one extra per file */ ! 145: nhist++; ! 146: nfiles++; ! 147: } ! 148: nhist++; ! 149: break; ! 150: default: ! 151: break; ! 152: } ! 153: } ! 154: if (debug) ! 155: print("NG: %d NT: %d NF: %d\n", nglob, ntxt, fmax); ! 156: if (fp->sppcsz) { /* pc-sp offset table */ ! 157: spoff = (uchar *)malloc(fp->sppcsz); ! 158: if(spoff == 0) { ! 159: werrstr("can't malloc %d bytes", fp->sppcsz); ! 160: return -1; ! 161: } ! 162: Bseek(&b, fp->sppcoff, 0); ! 163: i = Bread(&b, spoff, fp->sppcsz); ! 164: if(i != fp->sppcsz){ ! 165: spoff = 0; ! 166: return symerrmsg(fp->sppcsz, "sp-pc"); ! 167: } ! 168: spoffend = spoff+fp->sppcsz; ! 169: } ! 170: if (fp->lnpcsz) { /* pc-line number table */ ! 171: pcline = (uchar *)malloc(fp->lnpcsz); ! 172: if(pcline == 0) { ! 173: werrstr("can't malloc %d bytes", fp->lnpcsz); ! 174: return -1; ! 175: } ! 176: Bseek(&b, fp->lnpcoff, 0); ! 177: i = Bread(&b, pcline, fp->lnpcsz); ! 178: if(i != fp->lnpcsz){ ! 179: pcline = 0; ! 180: return symerrmsg(fp->lnpcsz, "pc-line"); ! 181: } ! 182: pclineend = pcline+fp->lnpcsz; ! 183: } ! 184: return nsym; ! 185: } ! 186: ! 187: static int ! 188: symerrmsg(int n, char *table) ! 189: { ! 190: werrstr("can't read %d bytes of %s table", n, table); ! 191: return -1; ! 192: } ! 193: ! 194: static int ! 195: decodename(Biobuf *bp, Sym *p) ! 196: { ! 197: char *cp; ! 198: int c1, c2; ! 199: int n; ! 200: ! 201: if((p->type & 0x80) == 0) { /* old-style, fixed length names */ ! 202: p->name = malloc(NNAME); ! 203: if(p->name == 0) { ! 204: werrstr("can't malloc %d bytes", NNAME); ! 205: return -1; ! 206: } ! 207: if(Bread(bp, p->name, NNAME) != NNAME) ! 208: return symerrmsg(NNAME, "symbol"); ! 209: Bseek(bp, 3, 1); ! 210: return NNAME+3; ! 211: } ! 212: ! 213: p->type &= ~0x80; ! 214: if(p->type == 'z' || p->type == 'Z') { ! 215: n = Bseek(bp, 0, 1); ! 216: if(Bgetc(bp) < 0) { ! 217: werrstr("can't read symbol name"); ! 218: return -1; ! 219: } ! 220: for(;;) { ! 221: c1 = Bgetc(bp); ! 222: c2 = Bgetc(bp); ! 223: if(c1 < 0 || c2 < 0) { ! 224: werrstr("can't read symbol name"); ! 225: return -1; ! 226: } ! 227: if(c1 == 0 && c2 == 0) ! 228: break; ! 229: } ! 230: n = Bseek(bp, 0, 1)-n; ! 231: p->name = malloc(n); ! 232: if(p->name == 0) { ! 233: werrstr("can't malloc %d bytes", n); ! 234: return -1; ! 235: } ! 236: Bseek(bp, -n, 1); ! 237: if(Bread(bp, p->name, n) != n) { ! 238: werrstr("can't read %d bytes of symbol name", n); ! 239: return -1; ! 240: } ! 241: } else { ! 242: cp = Brdline(bp, '\0'); ! 243: if(cp == 0) { ! 244: werrstr("can't read symbol name"); ! 245: return -1; ! 246: } ! 247: n = Blinelen(bp); ! 248: p->name = malloc(n); ! 249: if(p->name == 0) { ! 250: werrstr("can't malloc %d bytes", n); ! 251: return -1; ! 252: } ! 253: strcpy(p->name, cp); ! 254: } ! 255: return n; ! 256: } ! 257: /* ! 258: * free any previously loaded symbol tables ! 259: */ ! 260: static void ! 261: cleansyms(void) ! 262: { ! 263: if(globals) ! 264: free(globals); ! 265: globals = 0; ! 266: nglob = 0; ! 267: if(txt) ! 268: free(txt); ! 269: txt = 0; ! 270: ntxt = 0; ! 271: if(fnames) ! 272: free(fnames); ! 273: fnames = 0; ! 274: fmax = 0; ! 275: ! 276: if(files) ! 277: free(files); ! 278: files = 0; ! 279: nfiles = 0; ! 280: if(hist) ! 281: free(hist); ! 282: hist = 0; ! 283: nhist = 0; ! 284: if(autos) ! 285: free(autos); ! 286: autos = 0; ! 287: nauto = 0; ! 288: isbuilt = 0; ! 289: if(symbols) ! 290: free(symbols); ! 291: symbols = 0; ! 292: nsym = 0; ! 293: if(spoff) ! 294: free(spoff); ! 295: spoff = 0; ! 296: if(pcline) ! 297: free(pcline); ! 298: pcline = 0; ! 299: } ! 300: /* ! 301: * delimit the text segment ! 302: */ ! 303: void ! 304: textseg(ulong base, Fhdr *fp) ! 305: { ! 306: txtstart = base; ! 307: txtend = base+fp->txtsz; ! 308: } ! 309: /* ! 310: * symbase: return base and size of raw symbol table ! 311: * (special hack for high access rate operations) ! 312: */ ! 313: Sym * ! 314: symbase(long *n) ! 315: { ! 316: *n = nsym; ! 317: return symbols; ! 318: } ! 319: /* ! 320: * Get the ith symbol table entry ! 321: */ ! 322: Sym * ! 323: getsym(int index) ! 324: { ! 325: if(index < nsym) ! 326: return &symbols[index]; ! 327: return 0; ! 328: } ! 329: ! 330: /* ! 331: * initialize internal symbol tables ! 332: */ ! 333: static int ! 334: buildtbls(void) ! 335: { ! 336: int i, j, nh, ng, nt; ! 337: File *f; ! 338: Txtsym *tp; ! 339: Hist *hp; ! 340: Sym *p, **ap; ! 341: ! 342: if(isbuilt) ! 343: return 1; ! 344: isbuilt = 1; ! 345: /* allocate the tables */ ! 346: if(nglob) { ! 347: globals = malloc(nglob*sizeof(*globals)); ! 348: if(!globals) { ! 349: werrstr("can't malloc global symbol table"); ! 350: return 0; ! 351: } ! 352: } ! 353: if(ntxt) { ! 354: txt = malloc(ntxt*sizeof(*txt)); ! 355: if (!txt) { ! 356: werrstr("can't malloc text symbol table"); ! 357: return 0; ! 358: } ! 359: } ! 360: fmax++; ! 361: fnames = malloc(fmax*sizeof(*fnames)); ! 362: if (!fnames) { ! 363: werrstr("can't malloc file name table"); ! 364: return 0; ! 365: } ! 366: memset(fnames, 0, fmax*sizeof(*fnames)); ! 367: files = malloc(nfiles*sizeof(*files)); ! 368: if(!files) { ! 369: werrstr("can't malloc file table"); ! 370: return 0; ! 371: } ! 372: hist = malloc(nhist*sizeof(Hist)); ! 373: if(hist == 0) { ! 374: werrstr("can't malloc history stack"); ! 375: return 0; ! 376: } ! 377: autos = malloc(nauto*sizeof(Sym*)); ! 378: if(autos == 0) { ! 379: werrstr("can't malloc auto symbol table"); ! 380: return 0; ! 381: } ! 382: /* load the tables */ ! 383: ng = nt = nh = 0; ! 384: f = 0; ! 385: tp = 0; ! 386: i = nsym; ! 387: hp = hist; ! 388: ap = autos; ! 389: for(p = symbols; i-- > 0; p++) { ! 390: switch(p->type) { ! 391: case 'D': ! 392: case 'd': ! 393: case 'B': ! 394: case 'b': ! 395: if(debug) ! 396: print("Global: %s %lux\n", p->name, p->value); ! 397: globals[ng++] = p; ! 398: break; ! 399: case 'z': ! 400: if(p->value == 1) { /* New file */ ! 401: if(f) { ! 402: f->n = nh; ! 403: f->hist[nh].name = 0; /* one extra */ ! 404: hp += nh+1; ! 405: f++; ! 406: } ! 407: else f = files; ! 408: f->hist = hp; ! 409: f->sym = 0; ! 410: f->addr = 0; ! 411: nh = 0; ! 412: } ! 413: /* alloc one slot extra as terminator */ ! 414: f->hist[nh].name = p->name; ! 415: f->hist[nh].line = p->value; ! 416: f->hist[nh].offset = 0; ! 417: if(debug) ! 418: printhist("-> ", &f->hist[nh], 1); ! 419: nh++; ! 420: break; ! 421: case 'Z': ! 422: if(f && nh > 0) ! 423: f->hist[nh-1].offset = p->value; ! 424: break; ! 425: case 'T': ! 426: case 't': /* Text: terminate history if first in file */ ! 427: case 'L': ! 428: case 'l': ! 429: tp = &txt[nt++]; ! 430: tp->n = 0; ! 431: tp->sym = p; ! 432: tp->locals = ap; ! 433: if(debug) ! 434: print("TEXT: %s at %lux\n", p->name, p->value); ! 435: if(f && !f->sym) { /* first */ ! 436: f->sym = p; ! 437: f->addr = p->value; ! 438: } ! 439: break; ! 440: case 'a': ! 441: case 'p': ! 442: case 'm': /* Local Vars */ ! 443: if(!tp) ! 444: print("Warning: Free floating local var"); ! 445: else { ! 446: if(debug) ! 447: print("Local: %s %lux\n", p->name, p->value); ! 448: tp->locals[tp->n] = p; ! 449: tp->n++; ! 450: ap++; ! 451: } ! 452: break; ! 453: case 'f': /* File names */ ! 454: if(debug) ! 455: print("Fname: %s\n", p->name); ! 456: fnames[p->value] = p; ! 457: break; ! 458: default: ! 459: break; ! 460: } ! 461: } ! 462: /* sort global and text tables into ascending address order */ ! 463: qsort(globals, nglob, sizeof(Sym*), symcomp); ! 464: qsort(txt, ntxt, sizeof(Txtsym), txtcomp); ! 465: qsort(files, nfiles, sizeof(File), filecomp); ! 466: tp = txt; ! 467: for(i = 0, f = files; i < nfiles; i++, f++) { ! 468: for(j = 0; j < ntxt; j++) { ! 469: if(f->sym == tp->sym) { ! 470: if(debug) { ! 471: print("LINK: %s to", f->sym->name); ! 472: printhist("... ", f->hist, 1); ! 473: } ! 474: f->txt = tp++; ! 475: break; ! 476: } ! 477: if(++tp >= txt+ntxt) /* wrap around */ ! 478: tp = txt; ! 479: } ! 480: } ! 481: return 1; ! 482: } ! 483: ! 484: /* ! 485: * find symbol function.var by name. ! 486: * fn != 0 && var != 0 => look for fn in text, var in data ! 487: * fn != 0 && var == 0 => look for fn in text ! 488: * fn == 0 && var != 0 => look for var first in text then in data space. ! 489: */ ! 490: int ! 491: lookup(char *fn, char *var, Symbol *s) ! 492: { ! 493: int found; ! 494: ! 495: if(buildtbls() == 0) ! 496: return 0; ! 497: if(fn) { ! 498: found = findtext(fn, s); ! 499: if(var == 0) /* case 2: fn not in text */ ! 500: return found; ! 501: else if(!found) /* case 1: fn not found */ ! 502: return 0; ! 503: } else if(var) { ! 504: found = findtext(var, s); ! 505: if(found) ! 506: return 1; /* case 3: var found in text */ ! 507: } else return 0; /* case 4: fn & var == zero */ ! 508: ! 509: if(found) ! 510: return findlocal(s, var, s); /* case 1: fn found */ ! 511: return findglobal(var, s); /* case 3: var not found */ ! 512: ! 513: } ! 514: /* ! 515: * find a function by name ! 516: */ ! 517: static int ! 518: findtext(char *name, Symbol *s) ! 519: { ! 520: int i; ! 521: ! 522: for(i = 0; i < ntxt; i++) { ! 523: if(strcmp(txt[i].sym->name, name) == 0) { ! 524: fillsym(txt[i].sym, s); ! 525: s->handle = (void *) &txt[i]; ! 526: return 1; ! 527: } ! 528: } ! 529: return 0; ! 530: } ! 531: /* ! 532: * find global variable by name ! 533: */ ! 534: static int ! 535: findglobal(char *name, Symbol *s) ! 536: { ! 537: int i; ! 538: ! 539: for(i = 0; i < nglob; i++) { ! 540: if(strcmp(globals[i]->name, name) == 0) { ! 541: fillsym(globals[i], s); ! 542: return 1; ! 543: } ! 544: } ! 545: return 0; ! 546: } ! 547: /* ! 548: * find the local variable by name within a given function ! 549: */ ! 550: int ! 551: findlocal(Symbol *s1, char *name, Symbol *s2) ! 552: { ! 553: if(s1 == 0) ! 554: return 0; ! 555: if(buildtbls() == 0) ! 556: return 0; ! 557: return findlocvar(s1, name, s2); ! 558: } ! 559: /* ! 560: * find the local variable by name within a given function ! 561: * (internal function - does no parameter validation) ! 562: */ ! 563: static int ! 564: findlocvar(Symbol *s1, char *name, Symbol *s2) ! 565: { ! 566: Txtsym *tp; ! 567: int i; ! 568: ! 569: tp = (Txtsym *)s1->handle; ! 570: if(tp && tp->locals) { ! 571: for(i = 0; i < tp->n; i++) ! 572: if (strcmp(tp->locals[i]->name, name) == 0) { ! 573: fillsym(tp->locals[i], s2); ! 574: s2->handle = (void *)tp; ! 575: return 1; ! 576: } ! 577: } ! 578: return 0; ! 579: } ! 580: /* ! 581: * Get ith text symbol ! 582: */ ! 583: int ! 584: textsym(Symbol *s, int index) ! 585: { ! 586: ! 587: if(buildtbls() == 0) ! 588: return 0; ! 589: if(index >= ntxt) ! 590: return 0; ! 591: fillsym(txt[index].sym, s); ! 592: s->handle = (void *)&txt[index]; ! 593: return 1; ! 594: } ! 595: /* ! 596: * Get ith file name ! 597: */ ! 598: int ! 599: filesym(int index, char *buf, int n) ! 600: { ! 601: Hist *hp; ! 602: ! 603: if(buildtbls() == 0) ! 604: return 0; ! 605: if(index >= nfiles) ! 606: return 0; ! 607: hp = files[index].hist; ! 608: if(!hp || !hp->name) ! 609: return 0; ! 610: return fileelem(fnames, (uchar*)hp->name, buf, n); ! 611: } ! 612: /* ! 613: * Lookup name of local variable located at an offset into the frame. ! 614: * The type selects either a parameter or automatic. ! 615: */ ! 616: int ! 617: getauto(Symbol *s1, int off, int type, Symbol *s2) ! 618: { ! 619: Txtsym *tp; ! 620: Sym *p; ! 621: int i, t; ! 622: ! 623: if(s1 == 0) ! 624: return 0; ! 625: if(type == CPARAM) ! 626: t = 'p'; ! 627: else if(type == CAUTO) ! 628: t = 'a'; ! 629: else ! 630: return 0; ! 631: if(buildtbls() == 0) ! 632: return 0; ! 633: tp = (Txtsym *)s1->handle; ! 634: if(tp == 0) ! 635: return 0; ! 636: for(i = 0; i < tp->n; i++) { ! 637: p = tp->locals[i]; ! 638: if(p->type == t && p->value == off) { ! 639: fillsym(p, s2); ! 640: s2->handle = s1->handle; ! 641: return 1; ! 642: } ! 643: } ! 644: return 0; ! 645: } ! 646: ! 647: /* ! 648: * Find text symbol containing addr; binary search assumes text array is sorted by addr ! 649: */ ! 650: static int ! 651: srchtext(long addr) ! 652: { ! 653: ulong val; ! 654: int top, bot, mid; ! 655: Sym *sp; ! 656: ! 657: val = addr; ! 658: bot = 0; ! 659: top = ntxt; ! 660: for (mid = (bot+top)/2; mid < top; mid = (bot+top)/2) { ! 661: sp = txt[mid].sym; ! 662: if(val < (ulong)sp->value) ! 663: top = mid; ! 664: else if(mid != ntxt-1 && val >= (ulong)txt[mid+1].sym->value) ! 665: bot = mid; ! 666: else ! 667: return mid; ! 668: } ! 669: return -1; ! 670: } ! 671: ! 672: /* ! 673: * Find data symbol containing addr; binary search assumes data array is sorted by addr ! 674: */ ! 675: static ! 676: int srchdata(long addr) ! 677: { ! 678: ulong val; ! 679: int top, bot, mid; ! 680: Sym *sp; ! 681: ! 682: bot = 0; ! 683: top = nglob; ! 684: val = addr; ! 685: for(mid = (bot+top)/2; mid < top; mid = (bot+top)/2) { ! 686: sp = globals[mid]; ! 687: if(val < (ulong)sp->value) ! 688: top = mid; ! 689: else if(mid < nglob-1 && val >= (ulong)globals[mid+1]->value) ! 690: bot = mid; ! 691: else ! 692: return mid; ! 693: } ! 694: return -1; ! 695: } ! 696: /* ! 697: * Find symbol containing val in specified search space ! 698: * There is a special case when a value falls beyond the end ! 699: * of the text segment; if the search space is CTEXT, that value ! 700: * (usually etext) is returned. If the search space is CANY, symbols in the ! 701: * data space are searched for a match. ! 702: */ ! 703: int ! 704: findsym(long w, int type, Symbol *s) ! 705: { ! 706: int i; ! 707: ! 708: if(buildtbls() == 0) ! 709: return 0; ! 710: ! 711: if(type == CTEXT || type == CANY) { ! 712: i = srchtext(w); ! 713: if(i >= 0) { ! 714: if(type == CTEXT || i != ntxt-1) { ! 715: fillsym(txt[i].sym, s); ! 716: s->handle = (void *) &txt[i]; ! 717: return 1; ! 718: } ! 719: } ! 720: } ! 721: if(type == CDATA || type == CANY) { ! 722: i = srchdata(w); ! 723: if(i >= 0) { ! 724: fillsym(globals[i], s); ! 725: return 1; ! 726: } ! 727: } ! 728: return 0; ! 729: } ! 730: ! 731: /* ! 732: * Find the start and end address of the function containing addr ! 733: */ ! 734: int ! 735: fnbound(long addr, ulong *bounds) ! 736: { ! 737: int i; ! 738: ! 739: if(buildtbls() == 0) ! 740: return 0; ! 741: ! 742: i = srchtext(addr); ! 743: if(0 <= i && i < ntxt-1) { ! 744: bounds[0] = txt[i].sym->value; ! 745: bounds[1] = txt[i+1].sym->value; ! 746: return 1; ! 747: } ! 748: return 0; ! 749: } ! 750: ! 751: /* ! 752: * get the ith local symbol for a function ! 753: * the input symbol table is reverse ordered, so we reverse ! 754: * accesses here to maintain approx. parameter ordering in a stack trace. ! 755: */ ! 756: int ! 757: localsym(Symbol *s, int index) ! 758: { ! 759: Txtsym *tp; ! 760: ! 761: if(s == 0) ! 762: return 0; ! 763: if(buildtbls() == 0) ! 764: return 0; ! 765: ! 766: tp = (Txtsym *)s->handle; ! 767: if(tp && tp->locals && index < tp->n) { ! 768: fillsym(tp->locals[tp->n-index-1], s); /* reverse */ ! 769: s->handle = (void *)tp; ! 770: return 1; ! 771: } ! 772: return 0; ! 773: } ! 774: /* ! 775: * get the ith global symbol ! 776: */ ! 777: int ! 778: globalsym(Symbol *s, int index) ! 779: { ! 780: if(s == 0) ! 781: return 0; ! 782: if(buildtbls() == 0) ! 783: return 0; ! 784: ! 785: if(index < nglob) { ! 786: fillsym(globals[index], s); ! 787: return 1; ! 788: } ! 789: return 0; ! 790: } ! 791: /* ! 792: * find the pc given a file name and line offset into it. ! 793: */ ! 794: long ! 795: file2pc(char *file, ulong line) ! 796: { ! 797: File *fp; ! 798: int i; ! 799: long pc; ! 800: ulong start, end; ! 801: short *name; ! 802: ! 803: if(buildtbls() == 0 || files == 0) ! 804: return -1; ! 805: name = encfname(file); ! 806: if(name == 0) { /* encode the file name */ ! 807: werrstr("file %s not found", file); ! 808: return -1; ! 809: } ! 810: /* find this history stack */ ! 811: for(i = 0, fp = files; i < nfiles; i++, fp++) ! 812: if (hline(fp, name, &line)) ! 813: break; ! 814: free(name); ! 815: if(i >= nfiles) { ! 816: werrstr("line %d in file %s not found", line, file); ! 817: return -1; ! 818: } ! 819: start = fp->addr; /* first text addr this file */ ! 820: if(i < nfiles-1) ! 821: end = (fp+1)->addr; /* first text addr next file */ ! 822: else ! 823: end = 0; /* last file in load module */ ! 824: /* ! 825: * At this point, line contains the offset into the file. ! 826: * run the state machine to locate the pc closest to that value. ! 827: */ ! 828: if(debug) ! 829: print("find pc for %d - between: %lux and %lux\n", line, start, end); ! 830: pc = line2addr(line, start, end); ! 831: if(pc == -1) { ! 832: werrstr("line %d not in file %s", line, file); ! 833: return -1; ! 834: } ! 835: return pc; ! 836: } ! 837: /* ! 838: * search for a path component index ! 839: */ ! 840: static int ! 841: pathcomp(char *s, int n) ! 842: { ! 843: int i; ! 844: ! 845: for(i = 0; i <= fmax; i++) ! 846: if(fnames[i] && strncmp(s, fnames[i]->name, n) == 0) ! 847: return i; ! 848: return -1; ! 849: } ! 850: /* ! 851: * Encode a char file name as a sequence of short indices ! 852: * into the file name dictionary. ! 853: */ ! 854: static short* ! 855: encfname(char *file) ! 856: { ! 857: int i, j; ! 858: char *cp, *cp2; ! 859: short *dest; ! 860: ! 861: if(*file == '/') /* always check first '/' */ ! 862: cp2 = file+1; ! 863: else { ! 864: cp2 = strchr(file, '/'); ! 865: if(!cp2) ! 866: cp2 = strchr(file, 0); ! 867: } ! 868: cp = file; ! 869: dest = 0; ! 870: for(i = 0; *cp; i++) { ! 871: j = pathcomp(cp, cp2-cp); ! 872: if(j < 0) ! 873: return 0; /* not found */ ! 874: dest = realloc(dest, (i+1)*sizeof(short)); ! 875: dest[i] = j; ! 876: cp = cp2; ! 877: while(*cp == '/') /* skip embedded '/'s */ ! 878: cp++; ! 879: cp2 = strchr(cp, '/'); ! 880: if(!cp2) ! 881: cp2 = strchr(cp, 0); ! 882: } ! 883: dest = realloc(dest, (i+1)*sizeof(short)); ! 884: dest[i] = 0; ! 885: return dest; ! 886: } ! 887: /* ! 888: * Search a history stack for a matching file name accumulating ! 889: * the size of intervening files in the stack. ! 890: */ ! 891: static int ! 892: hline(File *fp, short *name, ulong *line) ! 893: { ! 894: Hist *hp; ! 895: int offset, depth; ! 896: long ln; ! 897: ! 898: for(hp = fp->hist; hp->name; hp++) /* find name in stack */ ! 899: if(hp->name[1] || hp->name[2]) { ! 900: if(hcomp(hp, name)) ! 901: break; ! 902: } ! 903: if(!hp->name) /* match not found */ ! 904: return 0; ! 905: if(debug) ! 906: printhist("hline found ... ", hp, 1); ! 907: /* ! 908: * unwind the stack until empty or we hit an entry beyond our line ! 909: */ ! 910: ln = *line; ! 911: offset = hp->line-1; ! 912: depth = 1; ! 913: for(hp++; depth && hp->name; hp++) { ! 914: if(debug) ! 915: printhist("hline inspect ... ", hp, 1); ! 916: if(hp->name[1] || hp->name[2]) { ! 917: if(hp->offset){ /* Z record */ ! 918: offset = 0; ! 919: if(hcomp(hp, name)) { ! 920: if(*line <= hp->offset) ! 921: break; ! 922: ln = *line+hp->line-hp->offset; ! 923: depth = 1; /* implicit pop */ ! 924: } else ! 925: depth = 2; /* implicit push */ ! 926: } else if(depth == 1 && ln < hp->line-offset) ! 927: break; /* Beyond our line */ ! 928: else if(depth++ == 1) /* push */ ! 929: offset -= hp->line; ! 930: } else if(--depth == 1) /* pop */ ! 931: offset += hp->line; ! 932: } ! 933: *line = ln+offset; ! 934: return 1; ! 935: } ! 936: /* ! 937: * compare two encoded file names ! 938: */ ! 939: static int ! 940: hcomp(Hist *hp, short *sp) ! 941: { ! 942: uchar *cp; ! 943: int i, j; ! 944: short *s; ! 945: ! 946: cp = (uchar *)hp->name; ! 947: s = sp; ! 948: if (*s == 0) ! 949: return 0; ! 950: for (i = 1; j = (cp[i]<<8)|cp[i+1]; i += 2) { ! 951: if(j == 0) ! 952: break; ! 953: if(*s == j) ! 954: s++; ! 955: else ! 956: s = sp; ! 957: } ! 958: return *s == 0; ! 959: } ! 960: /* ! 961: * Convert a pc to a "file:line {file:line}" string. ! 962: */ ! 963: int ! 964: fileline(char *str, int n, ulong dot) ! 965: { ! 966: long line; ! 967: int top, bot, mid; ! 968: File *f; ! 969: ! 970: *str = 0; ! 971: if(buildtbls() == 0) ! 972: return 0; ! 973: ! 974: /* binary search assumes file list is sorted by addr */ ! 975: bot = 0; ! 976: top = nfiles; ! 977: for (mid = (bot+top)/2; mid < top; mid = (bot+top)/2) { ! 978: f = &files[mid]; ! 979: if(dot < f->addr) ! 980: top = mid; ! 981: else if(mid < nfiles-1 && dot >= (f+1)->addr) ! 982: bot = mid; ! 983: else { ! 984: line = pc2line(dot); ! 985: if(line > 0 && fline(str, n, line, f->hist)) ! 986: return 1; ! 987: break; ! 988: } ! 989: } ! 990: return 0; ! 991: } ! 992: ! 993: /* ! 994: * Convert a line number within a composite file to relative line ! 995: * number in a source file. A composite file is the source ! 996: * file with included files inserted in line. ! 997: */ ! 998: static Hist * ! 999: fline(char *str, int n, long line, Hist *base) ! 1000: { ! 1001: Hist *start; /* start of current level */ ! 1002: Hist *h; /* current entry */ ! 1003: int delta; /* sum of size of files this level */ ! 1004: int k; ! 1005: ! 1006: start = base; ! 1007: h = base; ! 1008: delta = h->line; ! 1009: while(h && h->name && line > h->line) { ! 1010: if(h->name[1] || h->name[2]) { ! 1011: if(h->offset != 0) { /* #line Directive */ ! 1012: delta = h->line-h->offset+1; ! 1013: start = h; ! 1014: base = h++; ! 1015: } else { /* beginning of File */ ! 1016: if(start == base) ! 1017: start = h++; ! 1018: else { ! 1019: h = fline(str, n, line, start); ! 1020: if(!h) ! 1021: break; ! 1022: } ! 1023: } ! 1024: } else { ! 1025: if(start == base) /* end of recursion level */ ! 1026: return h; ! 1027: else { /* end of included file */ ! 1028: delta += h->line-start->line; ! 1029: h++; ! 1030: start = base; ! 1031: } ! 1032: } ! 1033: } ! 1034: if(!h) ! 1035: return 0; ! 1036: if(start != base) ! 1037: line = line-start->line+1; ! 1038: else ! 1039: line = line-delta+1; ! 1040: if(!h->name) ! 1041: strncpy(str, "<eof>", n); ! 1042: else { ! 1043: k = fileelem(fnames, (uchar*)start->name, str, n); ! 1044: if(k+8 < n) ! 1045: sprint(str+k, ":%ld", line); ! 1046: } ! 1047: /**********Remove comments for complete back-trace of include sequence ! 1048: * if(start != base) { ! 1049: * k = strlen(str); ! 1050: * if(k+2 < n) { ! 1051: * str[k++] = ' '; ! 1052: * str[k++] = '{'; ! 1053: * } ! 1054: * k += fileelem(fnames, (uchar*) base->name, str+k, n-k); ! 1055: * if(k+10 < n) ! 1056: * sprint(str+k, ":%ld}", start->line-delta); ! 1057: * } ! 1058: ********************/ ! 1059: return h; ! 1060: } ! 1061: /* ! 1062: * convert an encoded file name to a string. ! 1063: */ ! 1064: int ! 1065: fileelem(Sym **fp, uchar *cp, char *buf, int n) ! 1066: { ! 1067: int i, j; ! 1068: char *c, *bp, *end; ! 1069: ! 1070: bp = buf; ! 1071: end = buf+n-1; ! 1072: for(i = 1; j = (cp[i]<<8)|cp[i+1]; i+=2){ ! 1073: c = fp[j]->name; ! 1074: if(bp != buf && bp[-1] != '/' && bp < end) ! 1075: *bp++ = '/'; ! 1076: while(bp < end && *c) ! 1077: *bp++ = *c++; ! 1078: } ! 1079: *bp = 0; ! 1080: return bp-buf; ! 1081: } ! 1082: /* ! 1083: * compare the values of two symbol table entries. ! 1084: */ ! 1085: static int ! 1086: symcomp(void *a, void *b) ! 1087: { ! 1088: return (*(Sym**)a)->value - (*(Sym**)b)->value; ! 1089: } ! 1090: /* ! 1091: * compare the values of the symbols referenced by two text table entries ! 1092: */ ! 1093: static int ! 1094: txtcomp(void *a, void *b) ! 1095: { ! 1096: return ((Txtsym*)a)->sym->value - ((Txtsym*)b)->sym->value; ! 1097: } ! 1098: /* ! 1099: * compare the values of the symbols referenced by two file table entries ! 1100: */ ! 1101: static int ! 1102: filecomp(void *a, void *b) ! 1103: { ! 1104: return ((File*)a)->addr - ((File*)b)->addr; ! 1105: } ! 1106: /* ! 1107: * fill an interface Symbol structure from a symbol table entry ! 1108: */ ! 1109: static void ! 1110: fillsym(Sym *sp, Symbol *s) ! 1111: { ! 1112: s->type = sp->type; ! 1113: s->value = sp->value; ! 1114: s->name = sp->name; ! 1115: switch(sp->type) { ! 1116: case 'b': ! 1117: case 'B': ! 1118: case 'D': ! 1119: case 'd': ! 1120: s->class = CDATA; ! 1121: break; ! 1122: case 't': ! 1123: case 'T': ! 1124: case 'l': ! 1125: case 'L': ! 1126: s->class = CTEXT; ! 1127: break; ! 1128: case 'a': ! 1129: s->class = CAUTO; ! 1130: break; ! 1131: case 'p': ! 1132: s->class = CPARAM; ! 1133: break; ! 1134: case 'm': ! 1135: s->class = CSTAB; ! 1136: break; ! 1137: default: ! 1138: s->class = CNONE; ! 1139: break; ! 1140: } ! 1141: s->handle = 0; ! 1142: } ! 1143: /* ! 1144: * find the stack frame, given the pc ! 1145: */ ! 1146: long ! 1147: pc2sp(ulong pc) ! 1148: { ! 1149: uchar *c; ! 1150: uchar u; ! 1151: ulong currpc; ! 1152: long currsp; ! 1153: ! 1154: if(spoff == 0) ! 1155: return -1; ! 1156: currsp = 0; ! 1157: currpc = txtstart - mach->pcquant; ! 1158: ! 1159: if(pc<currpc || pc>txtend) ! 1160: return -1; ! 1161: for(c = spoff; c < spoffend; c++) { ! 1162: if (currpc >= pc) ! 1163: return currsp; ! 1164: u = *c; ! 1165: if (u == 0) { ! 1166: currsp += (c[1]<<24)|(c[2]<<16)|(c[3]<<8)|c[4]; ! 1167: c += 4; ! 1168: } ! 1169: else if (u < 65) ! 1170: currsp += 4*u; ! 1171: else if (u < 129) ! 1172: currsp -= 4*(u-64); ! 1173: else ! 1174: currpc += mach->pcquant*(u-129); ! 1175: currpc += mach->pcquant; ! 1176: } ! 1177: return -1; ! 1178: } ! 1179: /* ! 1180: * find the source file line number for a given value of the pc ! 1181: */ ! 1182: long ! 1183: pc2line(ulong pc) ! 1184: { ! 1185: uchar *c; ! 1186: uchar u; ! 1187: ulong currpc; ! 1188: long currline; ! 1189: ! 1190: if(pcline == 0) ! 1191: return -1; ! 1192: currline = 0; ! 1193: currpc = txtstart-mach->pcquant; ! 1194: if(pc<currpc || pc>txtend) ! 1195: return -1; ! 1196: ! 1197: for(c = pcline; c < pclineend; c++) { ! 1198: if(currpc >= pc) ! 1199: return currline; ! 1200: u = *c; ! 1201: if(u == 0) { ! 1202: currline += (c[1]<<24)|(c[2]<<16)|(c[3]<<8)|c[4]; ! 1203: c += 4; ! 1204: } ! 1205: else if(u < 65) ! 1206: currline += u; ! 1207: else if(u < 129) ! 1208: currline -= (u-64); ! 1209: else ! 1210: currpc += mach->pcquant*(u-129); ! 1211: currpc += mach->pcquant; ! 1212: } ! 1213: return -1; ! 1214: } ! 1215: /* ! 1216: * find the pc associated with a line number ! 1217: * basepc and endpc are text addresses bounding the search. ! 1218: * if endpc == 0, the end of the table is used (i.e., no upper bound). ! 1219: * usually, basepc and endpc contain the first text address in ! 1220: * a file and the first text address in the following file, respectively. ! 1221: */ ! 1222: long ! 1223: line2addr(ulong line, ulong basepc, ulong endpc) ! 1224: { ! 1225: uchar *c; ! 1226: uchar u; ! 1227: ulong currpc; ! 1228: long currline; ! 1229: long delta, d; ! 1230: long pc, found; ! 1231: ! 1232: if(pcline == 0 || line == 0) ! 1233: return -1; ! 1234: ! 1235: currline = 0; ! 1236: currpc = txtstart-mach->pcquant; ! 1237: pc = -1; ! 1238: found = 0; ! 1239: delta = HUGEINT; ! 1240: ! 1241: for(c = pcline; c < pclineend; c++) { ! 1242: if(endpc && currpc >= endpc) /* end of file of interest */ ! 1243: break; ! 1244: if(currpc >= basepc) { /* proper file */ ! 1245: if(currline >= line) { ! 1246: d = currline-line; ! 1247: found = 1; ! 1248: } else ! 1249: d = line-currline; ! 1250: if(d < delta) { ! 1251: delta = d; ! 1252: pc = currpc; ! 1253: } ! 1254: } ! 1255: u = *c; ! 1256: if(u == 0) { ! 1257: currline += (c[1]<<24)|(c[2]<<16)|(c[3]<<8)|c[4]; ! 1258: c += 4; ! 1259: } ! 1260: else if(u < 65) ! 1261: currline += u; ! 1262: else if(u < 129) ! 1263: currline -= (u-64); ! 1264: else ! 1265: currpc += mach->pcquant*(u-129); ! 1266: currpc += mach->pcquant; ! 1267: } ! 1268: if(found) ! 1269: return pc; ! 1270: return -1; ! 1271: } ! 1272: /* ! 1273: * Print a history stack (debug). if count is 0, prints the whole stack ! 1274: */ ! 1275: void ! 1276: printhist(char *msg, Hist *hp, int count) ! 1277: { ! 1278: int i; ! 1279: uchar *cp; ! 1280: char buf[128]; ! 1281: ! 1282: i = 0; ! 1283: while(hp->name) { ! 1284: if(count && ++i > count) ! 1285: break; ! 1286: print("%s Line: %x (%d) Offset: %x (%d) Name: ", msg, ! 1287: hp->line, hp->line, hp->offset, hp->offset); ! 1288: for(cp = (uchar *)hp->name+1; (*cp<<8)|cp[1]; cp += 2) { ! 1289: if (cp != (uchar *)hp->name+1) ! 1290: print("/"); ! 1291: print("%x", (*cp<<8)|cp[1]); ! 1292: } ! 1293: fileelem(fnames, (uchar *) hp->name, buf, sizeof(buf)); ! 1294: print(" (%s)\n", buf); ! 1295: hp++; ! 1296: } ! 1297: } ! 1298: ! 1299: #ifdef DEBUG ! 1300: /* ! 1301: * print the history stack for a file. (debug only) ! 1302: * if (name == 0) => print all history stacks. ! 1303: */ ! 1304: void ! 1305: dumphist(char *name) ! 1306: { ! 1307: int i; ! 1308: File *f; ! 1309: short *fname; ! 1310: ! 1311: if(buildtbls() == 0) ! 1312: return; ! 1313: if(name) ! 1314: fname = encfname(name); ! 1315: for(i = 0, f = files; i < nfiles; i++, f++) ! 1316: if(fname == 0 || hcomp(f->hist, fname)) ! 1317: printhist("> ", f->hist, f->n); ! 1318: ! 1319: if(fname) ! 1320: free(fname); ! 1321: } ! 1322: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.