ref: 8a788aea84aad3bfbd5b39d78c1925654f3b9e14
dir: /utils/libmach/sym.c/
#include <lib9.h>
#include <bio.h>
#include "mach.h"
#define HUGEINT 0x7fffffff
#define NNAME 20 /* a relic of the past */
typedef struct txtsym Txtsym;
typedef struct file File;
typedef struct hist Hist;
struct txtsym { /* Text Symbol table */
int n; /* number of local vars */
Sym **locals; /* array of ptrs to autos */
Sym *sym; /* function symbol entry */
};
struct hist { /* Stack of include files & #line directives */
char *name; /* Assumes names Null terminated in file */
long line; /* line # where it was included */
long offset; /* line # of #line directive */
};
struct file { /* Per input file header to history stack */
uvlong addr; /* address of first text sym */
/* union { */
Txtsym *txt; /* first text symbol */
Sym *sym; /* only during initilization */
/* }; */
int n; /* size of history stack */
Hist *hist; /* history stack */
};
static int debug = 0;
static Sym **autos; /* Base of auto variables */
static File *files; /* Base of file arena */
static int fpmax; /* largest file path index */
static Sym **fnames; /* file names path component table */
static Sym **globals; /* globals by addr table */
static Hist *hist; /* base of history stack */
static int isbuilt; /* internal table init flag */
static long nauto; /* number of automatics */
static long nfiles; /* number of files */
static long nglob; /* number of globals */
static long nhist; /* number of history stack entries */
static long nsym; /* number of symbols */
static int ntxt; /* number of text symbols */
static uchar *pcline; /* start of pc-line state table */
static uchar *pclineend; /* end of pc-line table */
static uchar *spoff; /* start of pc-sp state table */
static uchar *spoffend; /* end of pc-sp offset table */
static Sym *symbols; /* symbol table */
static Txtsym *txt; /* Base of text symbol table */
static uvlong txtstart; /* start of text segment */
static uvlong txtend; /* end of text segment */
static void cleansyms(void);
static long decodename(Biobuf*, Sym*);
static short *encfname(char*);
static int fline(char*, int, long, Hist*, Hist**);
static void fillsym(Sym*, Symbol*);
static int findglobal(char*, Symbol*);
static int findlocvar(Symbol*, char *, Symbol*);
static int findtext(char*, Symbol*);
static int hcomp(Hist*, short*);
static int hline(File*, short*, long*);
static void printhist(char*, Hist*, int);
static int buildtbls(void);
static int symcomp(void*, void*);
static int symerrmsg(int, char*);
static int txtcomp(void*, void*);
static int filecomp(void*, void*);
/*
* initialize the symbol tables
*/
int
syminit(int fd, Fhdr *fp)
{
Sym *p;
long i, l, size;
vlong vl;
Biobuf b;
int svalsz;
if(fp->symsz == 0)
return 0;
if(fp->type == FNONE)
return 0;
cleansyms();
textseg(fp->txtaddr, fp);
/* minimum symbol record size = 4+1+2 bytes */
symbols = malloc((fp->symsz/(4+1+2)+1)*sizeof(Sym));
if(symbols == 0) {
werrstr("can't malloc %ld bytes", fp->symsz);
return -1;
}
Binit(&b, fd, OREAD);
Bseek(&b, fp->symoff, 0);
nsym = 0;
size = 0;
for(p = symbols; size < fp->symsz; p++, nsym++) {
if(fp->_magic && (fp->magic & HDR_MAGIC)){
svalsz = 8;
if(Bread(&b, &vl, 8) != 8)
return symerrmsg(8, "symbol");
p->value = beswav(vl);
}
else{
svalsz = 4;
if(Bread(&b, &l, 4) != 4)
return symerrmsg(4, "symbol");
p->value = (u32int)beswal(l);
}
if(Bread(&b, &p->type, sizeof(p->type)) != sizeof(p->type))
return symerrmsg(sizeof(p->value), "symbol");
i = decodename(&b, p);
if(i < 0)
return -1;
size += i+svalsz+sizeof(p->type);
/* count global & auto vars, text symbols, and file names */
switch (p->type) {
case 'l':
case 'L':
case 't':
case 'T':
ntxt++;
break;
case 'd':
case 'D':
case 'b':
case 'B':
nglob++;
break;
case 'f':
if(strcmp(p->name, ".frame") == 0) {
p->type = 'm';
nauto++;
}
else if(p->value > fpmax)
fpmax = p->value; /* highest path index */
break;
case 'a':
case 'p':
case 'm':
nauto++;
break;
case 'z':
if(p->value == 1) { /* one extra per file */
nhist++;
nfiles++;
}
nhist++;
break;
default:
break;
}
}
if (debug)
print("NG: %ld NT: %d NF: %d\n", nglob, ntxt, fpmax);
if (fp->sppcsz) { /* pc-sp offset table */
spoff = (uchar *)malloc(fp->sppcsz);
if(spoff == 0) {
werrstr("can't malloc %ld bytes", fp->sppcsz);
return -1;
}
Bseek(&b, fp->sppcoff, 0);
if(Bread(&b, spoff, fp->sppcsz) != fp->sppcsz){
spoff = 0;
return symerrmsg(fp->sppcsz, "sp-pc");
}
spoffend = spoff+fp->sppcsz;
}
if (fp->lnpcsz) { /* pc-line number table */
pcline = (uchar *)malloc(fp->lnpcsz);
if(pcline == 0) {
werrstr("can't malloc %ld bytes", fp->lnpcsz);
return -1;
}
Bseek(&b, fp->lnpcoff, 0);
if(Bread(&b, pcline, fp->lnpcsz) != fp->lnpcsz){
pcline = 0;
return symerrmsg(fp->lnpcsz, "pc-line");
}
pclineend = pcline+fp->lnpcsz;
}
return nsym;
}
static int
symerrmsg(int n, char *table)
{
werrstr("can't read %d bytes of %s table", n, table);
return -1;
}
static long
decodename(Biobuf *bp, Sym *p)
{
char *cp;
int c1, c2;
long n;
vlong o;
if((p->type & 0x80) == 0) { /* old-style, fixed length names */
p->name = malloc(NNAME);
if(p->name == 0) {
werrstr("can't malloc %d bytes", NNAME);
return -1;
}
if(Bread(bp, p->name, NNAME) != NNAME)
return symerrmsg(NNAME, "symbol");
Bseek(bp, 3, 1);
return NNAME+3;
}
p->type &= ~0x80;
if(p->type == 'z' || p->type == 'Z') {
o = Bseek(bp, 0, 1);
if(Bgetc(bp) < 0) {
werrstr("can't read symbol name");
return -1;
}
for(;;) {
c1 = Bgetc(bp);
c2 = Bgetc(bp);
if(c1 < 0 || c2 < 0) {
werrstr("can't read symbol name");
return -1;
}
if(c1 == 0 && c2 == 0)
break;
}
n = Bseek(bp, 0, 1)-o;
p->name = malloc(n);
if(p->name == 0) {
werrstr("can't malloc %ld bytes", n);
return -1;
}
Bseek(bp, -n, 1);
if(Bread(bp, p->name, n) != n) {
werrstr("can't read %ld bytes of symbol name", n);
return -1;
}
} else {
cp = Brdline(bp, '\0');
if(cp == 0) {
werrstr("can't read symbol name");
return -1;
}
n = Blinelen(bp);
p->name = malloc(n);
if(p->name == 0) {
werrstr("can't malloc %ld bytes", n);
return -1;
}
strcpy(p->name, cp);
}
return n;
}
/*
* free any previously loaded symbol tables
*/
static void
cleansyms(void)
{
if(globals)
free(globals);
globals = 0;
nglob = 0;
if(txt)
free(txt);
txt = 0;
ntxt = 0;
if(fnames)
free(fnames);
fnames = 0;
fpmax = 0;
if(files)
free(files);
files = 0;
nfiles = 0;
if(hist)
free(hist);
hist = 0;
nhist = 0;
if(autos)
free(autos);
autos = 0;
nauto = 0;
isbuilt = 0;
if(symbols)
free(symbols);
symbols = 0;
nsym = 0;
if(spoff)
free(spoff);
spoff = 0;
if(pcline)
free(pcline);
pcline = 0;
}
/*
* delimit the text segment
*/
void
textseg(uvlong base, Fhdr *fp)
{
txtstart = base;
txtend = base+fp->txtsz;
}
/*
* symbase: return base and size of raw symbol table
* (special hack for high access rate operations)
*/
Sym *
symbase(long *n)
{
*n = nsym;
return symbols;
}
/*
* Get the ith symbol table entry
*/
Sym *
getsym(int index)
{
if(index >= 0 && index < nsym)
return &symbols[index];
return 0;
}
/*
* initialize internal symbol tables
*/
static int
buildtbls(void)
{
long i;
int j, nh, ng, nt;
File *f;
Txtsym *tp;
Hist *hp;
Sym *p, **ap;
if(isbuilt)
return 1;
isbuilt = 1;
/* allocate the tables */
if(nglob) {
globals = malloc(nglob*sizeof(*globals));
if(!globals) {
werrstr("can't malloc global symbol table");
return 0;
}
}
if(ntxt) {
txt = malloc(ntxt*sizeof(*txt));
if (!txt) {
werrstr("can't malloc text symbol table");
return 0;
}
}
fnames = malloc((fpmax+1)*sizeof(*fnames));
if (!fnames) {
werrstr("can't malloc file name table");
return 0;
}
memset(fnames, 0, (fpmax+1)*sizeof(*fnames));
files = malloc(nfiles*sizeof(*files));
if(!files) {
werrstr("can't malloc file table");
return 0;
}
hist = malloc(nhist*sizeof(Hist));
if(hist == 0) {
werrstr("can't malloc history stack");
return 0;
}
autos = malloc(nauto*sizeof(Sym*));
if(autos == 0) {
werrstr("can't malloc auto symbol table");
return 0;
}
/* load the tables */
ng = nt = nh = 0;
f = 0;
tp = 0;
i = nsym;
hp = hist;
ap = autos;
for(p = symbols; i-- > 0; p++) {
switch(p->type) {
case 'D':
case 'd':
case 'B':
case 'b':
if(debug)
print("Global: %s %llux\n", p->name, p->value);
globals[ng++] = p;
break;
case 'z':
if(p->value == 1) { /* New file */
if(f) {
f->n = nh;
f->hist[nh].name = 0; /* one extra */
hp += nh+1;
f++;
}
else
f = files;
f->hist = hp;
f->sym = 0;
f->addr = 0;
nh = 0;
}
/* alloc one slot extra as terminator */
f->hist[nh].name = p->name;
f->hist[nh].line = p->value;
f->hist[nh].offset = 0;
if(debug)
printhist("-> ", &f->hist[nh], 1);
nh++;
break;
case 'Z':
if(f && nh > 0)
f->hist[nh-1].offset = p->value;
break;
case 'T':
case 't': /* Text: terminate history if first in file */
case 'L':
case 'l':
tp = &txt[nt++];
tp->n = 0;
tp->sym = p;
tp->locals = ap;
if(debug)
print("TEXT: %s at %llux\n", p->name, p->value);
if(f && !f->sym) { /* first */
f->sym = p;
f->addr = p->value;
}
break;
case 'a':
case 'p':
case 'm': /* Local Vars */
if(!tp)
print("Warning: Free floating local var: %s\n",
p->name);
else {
if(debug)
print("Local: %s %llux\n", p->name, p->value);
tp->locals[tp->n] = p;
tp->n++;
ap++;
}
break;
case 'f': /* File names */
if(debug)
print("Fname: %s\n", p->name);
fnames[p->value] = p;
break;
default:
break;
}
}
/* sort global and text tables into ascending address order */
qsort(globals, nglob, sizeof(Sym*), symcomp);
qsort(txt, ntxt, sizeof(Txtsym), txtcomp);
qsort(files, nfiles, sizeof(File), filecomp);
tp = txt;
for(i = 0, f = files; i < nfiles; i++, f++) {
for(j = 0; j < ntxt; j++) {
if(f->sym == tp->sym) {
if(debug) {
print("LINK: %s to at %llux", f->sym->name, f->addr);
printhist("... ", f->hist, 1);
}
f->txt = tp++;
break;
}
if(++tp >= txt+ntxt) /* wrap around */
tp = txt;
}
}
return 1;
}
/*
* find symbol function.var by name.
* fn != 0 && var != 0 => look for fn in text, var in data
* fn != 0 && var == 0 => look for fn in text
* fn == 0 && var != 0 => look for var first in text then in data space.
*/
int
lookup(char *fn, char *var, Symbol *s)
{
int found;
if(buildtbls() == 0)
return 0;
if(fn) {
found = findtext(fn, s);
if(var == 0) /* case 2: fn not in text */
return found;
else if(!found) /* case 1: fn not found */
return 0;
} else if(var) {
found = findtext(var, s);
if(found)
return 1; /* case 3: var found in text */
} else return 0; /* case 4: fn & var == zero */
if(found)
return findlocal(s, var, s); /* case 1: fn found */
return findglobal(var, s); /* case 3: var not found */
}
/*
* find a function by name
*/
static int
findtext(char *name, Symbol *s)
{
int i;
for(i = 0; i < ntxt; i++) {
if(strcmp(txt[i].sym->name, name) == 0) {
fillsym(txt[i].sym, s);
s->handle = (void *) &txt[i];
s->index = i;
return 1;
}
}
return 0;
}
/*
* find global variable by name
*/
static int
findglobal(char *name, Symbol *s)
{
long i;
for(i = 0; i < nglob; i++) {
if(strcmp(globals[i]->name, name) == 0) {
fillsym(globals[i], s);
s->index = i;
return 1;
}
}
return 0;
}
/*
* find the local variable by name within a given function
*/
int
findlocal(Symbol *s1, char *name, Symbol *s2)
{
if(s1 == 0)
return 0;
if(buildtbls() == 0)
return 0;
return findlocvar(s1, name, s2);
}
/*
* find the local variable by name within a given function
* (internal function - does no parameter validation)
*/
static int
findlocvar(Symbol *s1, char *name, Symbol *s2)
{
Txtsym *tp;
int i;
tp = (Txtsym *)s1->handle;
if(tp && tp->locals) {
for(i = 0; i < tp->n; i++)
if (strcmp(tp->locals[i]->name, name) == 0) {
fillsym(tp->locals[i], s2);
s2->handle = (void *)tp;
s2->index = tp->n-1 - i;
return 1;
}
}
return 0;
}
/*
* Get ith text symbol
*/
int
textsym(Symbol *s, int index)
{
if(buildtbls() == 0)
return 0;
if(index < 0 || index >= ntxt)
return 0;
fillsym(txt[index].sym, s);
s->handle = (void *)&txt[index];
s->index = index;
return 1;
}
/*
* Get ith file name
*/
int
filesym(int index, char *buf, int n)
{
Hist *hp;
if(buildtbls() == 0)
return 0;
if(index < 0 || index >= nfiles)
return 0;
hp = files[index].hist;
if(!hp || !hp->name)
return 0;
return fileelem(fnames, (uchar*)hp->name, buf, n);
}
/*
* Lookup name of local variable located at an offset into the frame.
* The type selects either a parameter or automatic.
*/
int
getauto(Symbol *s1, int off, int type, Symbol *s2)
{
Txtsym *tp;
Sym *p;
int i, t;
if(s1 == 0)
return 0;
if(type == CPARAM)
t = 'p';
else if(type == CAUTO)
t = 'a';
else
return 0;
if(buildtbls() == 0)
return 0;
tp = (Txtsym *)s1->handle;
if(tp == 0)
return 0;
for(i = 0; i < tp->n; i++) {
p = tp->locals[i];
if(p->type == t && p->value == off) {
fillsym(p, s2);
s2->handle = s1->handle;
s2->index = tp->n-1 - i;
return 1;
}
}
return 0;
}
/*
* Find text symbol containing addr; binary search assumes text array is sorted by addr
*/
static int
srchtext(uvlong addr)
{
uvlong val;
int top, bot, mid;
Sym *sp;
val = addr;
bot = 0;
top = ntxt;
for (mid = (bot+top)/2; mid < top; mid = (bot+top)/2) {
sp = txt[mid].sym;
if(val < sp->value)
top = mid;
else if(mid != ntxt-1 && val >= txt[mid+1].sym->value)
bot = mid;
else
return mid;
}
return -1;
}
/*
* Find data symbol containing addr; binary search assumes data array is sorted by addr
*/
static int
srchdata(uvlong addr)
{
uvlong val;
int top, bot, mid;
Sym *sp;
bot = 0;
top = nglob;
val = addr;
for(mid = (bot+top)/2; mid < top; mid = (bot+top)/2) {
sp = globals[mid];
if(val < sp->value)
top = mid;
else if(mid < nglob-1 && val >= globals[mid+1]->value)
bot = mid;
else
return mid;
}
return -1;
}
/*
* Find symbol containing val in specified search space
* There is a special case when a value falls beyond the end
* of the text segment; if the search space is CTEXT, that value
* (usually etext) is returned. If the search space is CANY, symbols in the
* data space are searched for a match.
*/
int
findsym(uvlong val, int type, Symbol *s)
{
int i;
if(buildtbls() == 0)
return 0;
if(type == CTEXT || type == CANY) {
i = srchtext(val);
if(i >= 0) {
if(type == CTEXT || i != ntxt-1) {
fillsym(txt[i].sym, s);
s->handle = (void *) &txt[i];
s->index = i;
return 1;
}
}
}
if(type == CDATA || type == CANY) {
i = srchdata(val);
if(i >= 0) {
fillsym(globals[i], s);
s->index = i;
return 1;
}
}
return 0;
}
/*
* Find the start and end address of the function containing addr
*/
int
fnbound(uvlong addr, uvlong *bounds)
{
int i;
if(buildtbls() == 0)
return 0;
i = srchtext(addr);
if(0 <= i && i < ntxt-1) {
bounds[0] = txt[i].sym->value;
bounds[1] = txt[i+1].sym->value;
return 1;
}
return 0;
}
/*
* get the ith local symbol for a function
* the input symbol table is reverse ordered, so we reverse
* accesses here to maintain approx. parameter ordering in a stack trace.
*/
int
localsym(Symbol *s, int index)
{
Txtsym *tp;
if(s == 0 || index < 0)
return 0;
if(buildtbls() == 0)
return 0;
tp = (Txtsym *)s->handle;
if(tp && tp->locals && index < tp->n) {
fillsym(tp->locals[tp->n-index-1], s); /* reverse */
s->handle = (void *)tp;
s->index = index;
return 1;
}
return 0;
}
/*
* get the ith global symbol
*/
int
globalsym(Symbol *s, int index)
{
if(s == 0)
return 0;
if(buildtbls() == 0)
return 0;
if(index >=0 && index < nglob) {
fillsym(globals[index], s);
s->index = index;
return 1;
}
return 0;
}
/*
* find the pc given a file name and line offset into it.
*/
uvlong
file2pc(char *file, long line)
{
File *fp;
long i;
uvlong pc, start, end;
short *name;
if(buildtbls() == 0 || files == 0)
return ~0;
name = encfname(file);
if(name == 0) { /* encode the file name */
werrstr("file %s not found", file);
return ~0;
}
/* find this history stack */
for(i = 0, fp = files; i < nfiles; i++, fp++)
if (hline(fp, name, &line))
break;
free(name);
if(i >= nfiles) {
werrstr("line %ld in file %s not found", line, file);
return ~0;
}
start = fp->addr; /* first text addr this file */
if(i < nfiles-1)
end = (fp+1)->addr; /* first text addr next file */
else
end = 0; /* last file in load module */
/*
* At this point, line contains the offset into the file.
* run the state machine to locate the pc closest to that value.
*/
if(debug)
print("find pc for %ld - between: %llux and %llux\n", line, start, end);
pc = line2addr(line, start, end);
if(pc == ~0) {
werrstr("line %ld not in file %s", line, file);
return ~0;
}
return pc;
}
/*
* search for a path component index
*/
static int
pathcomp(char *s, int n)
{
int i;
for(i = 0; i <= fpmax; i++)
if(fnames[i] && strncmp(s, fnames[i]->name, n) == 0)
return i;
return -1;
}
/*
* Encode a char file name as a sequence of short indices
* into the file name dictionary.
*/
static short*
encfname(char *file)
{
int i, j;
char *cp, *cp2;
short *dest;
if(*file == '/') /* always check first '/' */
cp2 = file+1;
else {
cp2 = strchr(file, '/');
if(!cp2)
cp2 = strchr(file, 0);
}
cp = file;
dest = 0;
for(i = 0; *cp; i++) {
j = pathcomp(cp, cp2-cp);
if(j < 0)
return 0; /* not found */
dest = realloc(dest, (i+1)*sizeof(short));
dest[i] = j;
cp = cp2;
while(*cp == '/') /* skip embedded '/'s */
cp++;
cp2 = strchr(cp, '/');
if(!cp2)
cp2 = strchr(cp, 0);
}
dest = realloc(dest, (i+1)*sizeof(short));
dest[i] = 0;
return dest;
}
/*
* Search a history stack for a matching file name accumulating
* the size of intervening files in the stack.
*/
static int
hline(File *fp, short *name, long *line)
{
Hist *hp;
int offset, depth;
long ln;
for(hp = fp->hist; hp->name; hp++) /* find name in stack */
if(hp->name[1] || hp->name[2]) {
if(hcomp(hp, name))
break;
}
if(!hp->name) /* match not found */
return 0;
if(debug)
printhist("hline found ... ", hp, 1);
/*
* unwind the stack until empty or we hit an entry beyond our line
*/
ln = *line;
offset = hp->line-1;
depth = 1;
for(hp++; depth && hp->name; hp++) {
if(debug)
printhist("hline inspect ... ", hp, 1);
if(hp->name[1] || hp->name[2]) {
if(hp->offset){ /* Z record */
offset = 0;
if(hcomp(hp, name)) {
if(*line <= hp->offset)
break;
ln = *line+hp->line-hp->offset;
depth = 1; /* implicit pop */
} else
depth = 2; /* implicit push */
} else if(depth == 1 && ln < hp->line-offset)
break; /* Beyond our line */
else if(depth++ == 1) /* push */
offset -= hp->line;
} else if(--depth == 1) /* pop */
offset += hp->line;
}
*line = ln+offset;
return 1;
}
/*
* compare two encoded file names
*/
static int
hcomp(Hist *hp, short *sp)
{
uchar *cp;
int i, j;
short *s;
cp = (uchar *)hp->name;
s = sp;
if (*s == 0)
return 0;
for (i = 1; j = (cp[i]<<8)|cp[i+1]; i += 2) {
if(j == 0)
break;
if(*s == j)
s++;
else
s = sp;
}
return *s == 0;
}
/*
* Convert a pc to a "file:line {file:line}" string.
*/
long
fileline(char *str, int n, uvlong dot)
{
long line, top, bot, mid;
File *f;
*str = 0;
if(buildtbls() == 0)
return 0;
/* binary search assumes file list is sorted by addr */
bot = 0;
top = nfiles;
for (mid = (bot+top)/2; mid < top; mid = (bot+top)/2) {
f = &files[mid];
if(dot < f->addr)
top = mid;
else if(mid < nfiles-1 && dot >= (f+1)->addr)
bot = mid;
else {
line = pc2line(dot);
if(line > 0 && fline(str, n, line, f->hist, 0) >= 0)
return 1;
break;
}
}
return 0;
}
/*
* Convert a line number within a composite file to relative line
* number in a source file. A composite file is the source
* file with included files inserted in line.
*/
static int
fline(char *str, int n, long line, Hist *base, Hist **ret)
{
Hist *start; /* start of current level */
Hist *h; /* current entry */
long delta; /* sum of size of files this level */
int k;
start = base;
h = base;
delta = h->line;
while(h && h->name && line > h->line) {
if(h->name[1] || h->name[2]) {
if(h->offset != 0) { /* #line Directive */
delta = h->line-h->offset+1;
start = h;
base = h++;
} else { /* beginning of File */
if(start == base)
start = h++;
else {
k = fline(str, n, line, start, &h);
if(k <= 0)
return k;
}
}
} else {
if(start == base && ret) { /* end of recursion level */
*ret = h;
return 1;
} else { /* end of included file */
delta += h->line-start->line;
h++;
start = base;
}
}
}
if(!h)
return -1;
if(start != base)
line = line-start->line+1;
else
line = line-delta+1;
if(!h->name)
strncpy(str, "<eof>", n);
else {
k = fileelem(fnames, (uchar*)start->name, str, n);
if(k+8 < n)
sprint(str+k, ":%ld", line);
}
/**********Remove comments for complete back-trace of include sequence
* if(start != base) {
* k = strlen(str);
* if(k+2 < n) {
* str[k++] = ' ';
* str[k++] = '{';
* }
* k += fileelem(fnames, (uchar*) base->name, str+k, n-k);
* if(k+10 < n)
* sprint(str+k, ":%ld}", start->line-delta);
* }
********************/
return 0;
}
/*
* convert an encoded file name to a string.
*/
int
fileelem(Sym **fp, uchar *cp, char *buf, int n)
{
int i, j;
char *c, *bp, *end;
bp = buf;
end = buf+n-1;
for(i = 1; j = (cp[i]<<8)|cp[i+1]; i+=2){
c = fp[j]->name;
if(bp != buf && bp[-1] != '/' && bp < end)
*bp++ = '/';
while(bp < end && *c)
*bp++ = *c++;
}
*bp = 0;
i = bp-buf;
if(i > 1) {
cleanname(buf);
i = strlen(buf);
}
return i;
}
/*
* compare the values of two symbol table entries.
*/
static int
symcomp(void *a, void *b)
{
int i;
i = (*(Sym**)a)->value - (*(Sym**)b)->value;
if (i)
return i;
return strcmp((*(Sym**)a)->name, (*(Sym**)b)->name);
}
/*
* compare the values of the symbols referenced by two text table entries
*/
static int
txtcomp(void *a, void *b)
{
return ((Txtsym*)a)->sym->value - ((Txtsym*)b)->sym->value;
}
/*
* compare the values of the symbols referenced by two file table entries
*/
static int
filecomp(void *a, void *b)
{
return ((File*)a)->addr - ((File*)b)->addr;
}
/*
* fill an interface Symbol structure from a symbol table entry
*/
static void
fillsym(Sym *sp, Symbol *s)
{
s->type = sp->type;
s->value = sp->value;
s->name = sp->name;
s->index = 0;
switch(sp->type) {
case 'b':
case 'B':
case 'D':
case 'd':
s->class = CDATA;
break;
case 't':
case 'T':
case 'l':
case 'L':
s->class = CTEXT;
break;
case 'a':
s->class = CAUTO;
break;
case 'p':
s->class = CPARAM;
break;
case 'm':
s->class = CSTAB;
break;
default:
s->class = CNONE;
break;
}
s->handle = 0;
}
/*
* find the stack frame, given the pc
*/
uvlong
pc2sp(uvlong pc)
{
uchar *c, u;
uvlong currpc, currsp;
if(spoff == 0)
return ~0;
currsp = 0;
currpc = txtstart - mach->pcquant;
if(pc<currpc || pc>txtend)
return ~0;
for(c = spoff; c < spoffend; c++) {
if (currpc >= pc)
return currsp;
u = *c;
if (u == 0) {
currsp += (c[1]<<24)|(c[2]<<16)|(c[3]<<8)|c[4];
c += 4;
}
else if (u < 65)
currsp += 4*u;
else if (u < 129)
currsp -= 4*(u-64);
else
currpc += mach->pcquant*(u-129);
currpc += mach->pcquant;
}
return ~0;
}
/*
* find the source file line number for a given value of the pc
*/
long
pc2line(uvlong pc)
{
uchar *c, u;
uvlong currpc;
long currline;
if(pcline == 0)
return -1;
currline = 0;
currpc = txtstart-mach->pcquant;
if(pc<currpc || pc>txtend)
return ~0;
for(c = pcline; c < pclineend; c++) {
if(currpc >= pc)
return currline;
u = *c;
if(u == 0) {
currline += (c[1]<<24)|(c[2]<<16)|(c[3]<<8)|c[4];
c += 4;
}
else if(u < 65)
currline += u;
else if(u < 129)
currline -= (u-64);
else
currpc += mach->pcquant*(u-129);
currpc += mach->pcquant;
}
return ~0;
}
/*
* find the pc associated with a line number
* basepc and endpc are text addresses bounding the search.
* if endpc == 0, the end of the table is used (i.e., no upper bound).
* usually, basepc and endpc contain the first text address in
* a file and the first text address in the following file, respectively.
*/
uvlong
line2addr(long line, uvlong basepc, uvlong endpc)
{
uchar *c, u;
uvlong currpc, pc;
long currline;
long delta, d;
int found;
if(pcline == 0 || line == 0)
return ~0;
currline = 0;
currpc = txtstart-mach->pcquant;
pc = ~0;
found = 0;
delta = HUGEINT;
for(c = pcline; c < pclineend; c++) {
if(endpc && currpc >= endpc) /* end of file of interest */
break;
if(currpc >= basepc) { /* proper file */
if(currline >= line) {
d = currline-line;
found = 1;
} else
d = line-currline;
if(d < delta) {
delta = d;
pc = currpc;
}
}
u = *c;
if(u == 0) {
currline += (c[1]<<24)|(c[2]<<16)|(c[3]<<8)|c[4];
c += 4;
}
else if(u < 65)
currline += u;
else if(u < 129)
currline -= (u-64);
else
currpc += mach->pcquant*(u-129);
currpc += mach->pcquant;
}
if(found)
return pc;
return ~0;
}
/*
* Print a history stack (debug). if count is 0, prints the whole stack
*/
static void
printhist(char *msg, Hist *hp, int count)
{
int i;
uchar *cp;
char buf[128];
i = 0;
while(hp->name) {
if(count && ++i > count)
break;
print("%s Line: %lx (%ld) Offset: %lx (%ld) Name: ", msg,
hp->line, hp->line, hp->offset, hp->offset);
for(cp = (uchar *)hp->name+1; (*cp<<8)|cp[1]; cp += 2) {
if (cp != (uchar *)hp->name+1)
print("/");
print("%x", (*cp<<8)|cp[1]);
}
fileelem(fnames, (uchar *) hp->name, buf, sizeof(buf));
print(" (%s)\n", buf);
hp++;
}
}
#ifdef DEBUG
/*
* print the history stack for a file. (debug only)
* if (name == 0) => print all history stacks.
*/
void
dumphist(char *name)
{
int i;
File *f;
short *fname;
if(buildtbls() == 0)
return;
if(name)
fname = encfname(name);
for(i = 0, f = files; i < nfiles; i++, f++)
if(fname == 0 || hcomp(f->hist, fname))
printhist("> ", f->hist, f->n);
if(fname)
free(fname);
}
#endif