| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Runtime symbol table parsing. |
| // |
| // The Go tools use a symbol table derived from the Plan 9 symbol table |
| // format. The symbol table is kept in its own section treated as |
| // read-only memory when the binary is running: the binary consults the |
| // table. |
| // |
| // The format used by Go 1.0 was basically the Plan 9 format. Each entry |
| // is variable sized but had this format: |
| // |
| // 4-byte value, big endian |
| // 1-byte type ([A-Za-z] + 0x80) |
| // name, NUL terminated (or for 'z' and 'Z' entries, double-NUL terminated) |
| // 4-byte Go type address, big endian (new in Go) |
| // |
| // In order to support greater interoperation with standard toolchains, |
| // Go 1.1 uses a more flexible yet smaller encoding of the entries. |
| // The overall structure is unchanged from Go 1.0 and, for that matter, |
| // from Plan 9. |
| // |
| // The Go 1.1 table is a re-encoding of the data in a Go 1.0 table. |
| // To identify a new table as new, it begins one of two eight-byte |
| // sequences: |
| // |
| // FF FF FF FD 00 00 00 xx - big endian new table |
| // FD FF FF FF 00 00 00 xx - little endian new table |
| // |
| // This sequence was chosen because old tables stop at an entry with type |
| // 0, so old code reading a new table will see only an empty table. The |
| // first four bytes are the target-endian encoding of 0xfffffffd. The |
| // final xx gives AddrSize, the width of a full-width address. |
| // |
| // After that header, each entry is encoded as follows. |
| // |
| // 1-byte type (0-51 + two flag bits) |
| // AddrSize-byte value, host-endian OR varint-encoded value |
| // AddrSize-byte Go type address OR nothing |
| // [n] name, terminated as before |
| // |
| // The type byte comes first, but 'A' encodes as 0 and 'a' as 26, so that |
| // the type itself is only in the low 6 bits. The upper two bits specify |
| // the format of the next two fields. If the 0x40 bit is set, the value |
| // is encoded as an full-width 4- or 8-byte target-endian word. Otherwise |
| // the value is a varint-encoded number. If the 0x80 bit is set, the Go |
| // type is present, again as a 4- or 8-byte target-endian word. If not, |
| // there is no Go type in this entry. The NUL-terminated name ends the |
| // entry. |
| |
| #include "runtime.h" |
| #include "defs_GOOS_GOARCH.h" |
| #include "os_GOOS.h" |
| #include "arch_GOARCH.h" |
| #include "malloc.h" |
| |
| extern byte pclntab[], epclntab[], symtab[], esymtab[]; |
| |
| typedef struct Sym Sym; |
| struct Sym |
| { |
| uintptr value; |
| byte symtype; |
| byte *name; |
| // byte *gotype; |
| }; |
| |
| static uintptr mainoffset; |
| |
| // A dynamically allocated string containing multiple substrings. |
| // Individual strings are slices of hugestring. |
| static String hugestring; |
| static int32 hugestring_len; |
| |
| extern void main·main(void); |
| |
| static uintptr |
| readword(byte **pp, byte *ep) |
| { |
| byte *p; |
| |
| p = *pp; |
| if(ep - p < sizeof(void*)) { |
| *pp = ep; |
| return 0; |
| } |
| *pp = p + sizeof(void*); |
| |
| // Hairy, but only one of these four cases gets compiled. |
| if(sizeof(void*) == 8) { |
| if(BigEndian) { |
| return ((uint64)p[0]<<56) | ((uint64)p[1]<<48) | ((uint64)p[2]<<40) | ((uint64)p[3]<<32) | |
| ((uint64)p[4]<<24) | ((uint64)p[5]<<16) | ((uint64)p[6]<<8) | ((uint64)p[7]); |
| } |
| return ((uint64)p[7]<<56) | ((uint64)p[6]<<48) | ((uint64)p[5]<<40) | ((uint64)p[4]<<32) | |
| ((uint64)p[3]<<24) | ((uint64)p[2]<<16) | ((uint64)p[1]<<8) | ((uint64)p[0]); |
| } |
| if(BigEndian) { |
| return ((uint32)p[0]<<24) | ((uint32)p[1]<<16) | ((uint32)p[2]<<8) | ((uint32)p[3]); |
| } |
| return ((uint32)p[3]<<24) | ((uint32)p[2]<<16) | ((uint32)p[1]<<8) | ((uint32)p[0]); |
| } |
| |
| // Walk over symtab, calling fn(&s) for each symbol. |
| static void |
| walksymtab(void (*fn)(Sym*)) |
| { |
| byte *p, *ep, *q; |
| Sym s; |
| int32 widevalue, havetype, shift; |
| |
| p = symtab; |
| ep = esymtab; |
| |
| // Table must begin with correct magic number. |
| if(ep - p < 8 || p[4] != 0x00 || p[5] != 0x00 || p[6] != 0x00 || p[7] != sizeof(void*)) |
| return; |
| if(BigEndian) { |
| if(p[0] != 0xff || p[1] != 0xff || p[2] != 0xff || p[3] != 0xfd) |
| return; |
| } else { |
| if(p[0] != 0xfd || p[1] != 0xff || p[2] != 0xff || p[3] != 0xff) |
| return; |
| } |
| p += 8; |
| |
| while(p < ep) { |
| s.symtype = p[0]&0x3F; |
| widevalue = p[0]&0x40; |
| havetype = p[0]&0x80; |
| if(s.symtype < 26) |
| s.symtype += 'A'; |
| else |
| s.symtype += 'a' - 26; |
| p++; |
| |
| // Value, either full-width or varint-encoded. |
| if(widevalue) { |
| s.value = readword(&p, ep); |
| } else { |
| s.value = 0; |
| shift = 0; |
| while(p < ep && (p[0]&0x80) != 0) { |
| s.value |= (uintptr)(p[0]&0x7F)<<shift; |
| shift += 7; |
| p++; |
| } |
| if(p >= ep) |
| break; |
| s.value |= (uintptr)p[0]<<shift; |
| p++; |
| } |
| |
| // Go type, if present. Ignored but must skip over. |
| if(havetype) |
| readword(&p, ep); |
| |
| // Name. |
| if(ep - p < 2) |
| break; |
| |
| s.name = p; |
| if(s.symtype == 'z' || s.symtype == 'Z') { |
| // path reference string - skip first byte, |
| // then 2-byte pairs ending at two zeros. |
| q = p+1; |
| for(;;) { |
| if(q+2 > ep) |
| return; |
| if(q[0] == '\0' && q[1] == '\0') |
| break; |
| q += 2; |
| } |
| p = q+2; |
| }else{ |
| q = runtime·mchr(p, '\0', ep); |
| if(q == nil) |
| break; |
| p = q+1; |
| } |
| |
| fn(&s); |
| } |
| } |
| |
| // Symtab walker; accumulates info about functions. |
| |
| static Func *func; |
| static int32 nfunc; |
| |
| static byte **fname; |
| static int32 nfname; |
| |
| static uint32 funcinit; |
| static Lock funclock; |
| static uintptr lastvalue; |
| |
| static void |
| dofunc(Sym *sym) |
| { |
| Func *f; |
| |
| switch(sym->symtype) { |
| case 't': |
| case 'T': |
| case 'l': |
| case 'L': |
| if(runtime·strcmp(sym->name, (byte*)"etext") == 0) |
| break; |
| if(sym->value < lastvalue) { |
| runtime·printf("symbols out of order: %p before %p\n", lastvalue, sym->value); |
| runtime·throw("malformed symbol table"); |
| } |
| lastvalue = sym->value; |
| if(func == nil) { |
| nfunc++; |
| break; |
| } |
| f = &func[nfunc++]; |
| f->name = runtime·gostringnocopy(sym->name); |
| f->entry = sym->value; |
| if(sym->symtype == 'L' || sym->symtype == 'l') |
| f->frame = -sizeof(uintptr); |
| break; |
| case 'm': |
| if(nfunc <= 0 || func == nil) |
| break; |
| if(runtime·strcmp(sym->name, (byte*)".frame") == 0) |
| func[nfunc-1].frame = sym->value; |
| else if(runtime·strcmp(sym->name, (byte*)".locals") == 0) |
| func[nfunc-1].locals = sym->value; |
| else if(runtime·strcmp(sym->name, (byte*)".args") == 0) |
| func[nfunc-1].args = sym->value; |
| else { |
| runtime·printf("invalid 'm' symbol named '%s'\n", sym->name); |
| runtime·throw("mangled symbol table"); |
| } |
| break; |
| case 'f': |
| if(fname == nil) { |
| if(sym->value >= nfname) { |
| if(sym->value >= 0x10000) { |
| runtime·printf("runtime: invalid symbol file index %p\n", sym->value); |
| runtime·throw("mangled symbol table"); |
| } |
| nfname = sym->value+1; |
| } |
| break; |
| } |
| fname[sym->value] = sym->name; |
| break; |
| } |
| } |
| |
| // put together the path name for a z entry. |
| // the f entries have been accumulated into fname already. |
| // returns the length of the path name. |
| static int32 |
| makepath(byte *buf, int32 nbuf, byte *path) |
| { |
| int32 n, len; |
| byte *p, *ep, *q; |
| |
| if(nbuf <= 0) |
| return 0; |
| |
| p = buf; |
| ep = buf + nbuf; |
| *p = '\0'; |
| for(;;) { |
| if(path[0] == 0 && path[1] == 0) |
| break; |
| n = (path[0]<<8) | path[1]; |
| path += 2; |
| if(n >= nfname) |
| break; |
| q = fname[n]; |
| len = runtime·findnull(q); |
| if(p+1+len >= ep) |
| break; |
| if(p > buf && p[-1] != '/') |
| *p++ = '/'; |
| runtime·memmove(p, q, len+1); |
| p += len; |
| } |
| return p - buf; |
| } |
| |
| // appends p to hugestring |
| static String |
| gostringn(byte *p, int32 l) |
| { |
| String s; |
| |
| if(l == 0) |
| return runtime·emptystring; |
| if(hugestring.str == nil) { |
| hugestring_len += l; |
| return runtime·emptystring; |
| } |
| s.str = hugestring.str + hugestring.len; |
| s.len = l; |
| hugestring.len += s.len; |
| runtime·memmove(s.str, p, l); |
| return s; |
| } |
| |
| // walk symtab accumulating path names for use by pc/ln table. |
| // don't need the full generality of the z entry history stack because |
| // there are no includes in go (and only sensible includes in our c); |
| // assume code only appear in top-level files. |
| static void |
| dosrcline(Sym *sym) |
| { |
| static byte srcbuf[1000]; |
| static struct { |
| String srcstring; |
| int32 aline; |
| int32 delta; |
| } files[200]; |
| static int32 incstart; |
| static int32 nfunc, nfile, nhist; |
| Func *f; |
| int32 i, l; |
| |
| switch(sym->symtype) { |
| case 't': |
| case 'T': |
| if(hugestring.str == nil) |
| break; |
| if(runtime·strcmp(sym->name, (byte*)"etext") == 0) |
| break; |
| f = &func[nfunc++]; |
| // find source file |
| for(i = 0; i < nfile - 1; i++) { |
| if (files[i+1].aline > f->ln0) |
| break; |
| } |
| f->src = files[i].srcstring; |
| f->ln0 -= files[i].delta; |
| break; |
| case 'z': |
| if(sym->value == 1) { |
| // entry for main source file for a new object. |
| l = makepath(srcbuf, sizeof srcbuf, sym->name+1); |
| nhist = 0; |
| nfile = 0; |
| if(nfile == nelem(files)) |
| return; |
| files[nfile].srcstring = gostringn(srcbuf, l); |
| files[nfile].aline = 0; |
| files[nfile++].delta = 0; |
| } else { |
| // push or pop of included file. |
| l = makepath(srcbuf, sizeof srcbuf, sym->name+1); |
| if(srcbuf[0] != '\0') { |
| if(nhist++ == 0) |
| incstart = sym->value; |
| if(nhist == 0 && nfile < nelem(files)) { |
| // new top-level file |
| files[nfile].srcstring = gostringn(srcbuf, l); |
| files[nfile].aline = sym->value; |
| // this is "line 0" |
| files[nfile++].delta = sym->value - 1; |
| } |
| }else{ |
| if(--nhist == 0) |
| files[nfile-1].delta += sym->value - incstart; |
| } |
| } |
| } |
| } |
| |
| // Interpret pc/ln table, saving the subpiece for each func. |
| static void |
| splitpcln(void) |
| { |
| int32 line; |
| uintptr pc; |
| byte *p, *ep; |
| Func *f, *ef; |
| int32 pcquant; |
| |
| if(pclntab == epclntab || nfunc == 0) |
| return; |
| |
| switch(thechar) { |
| case '5': |
| pcquant = 4; |
| break; |
| default: // 6, 8 |
| pcquant = 1; |
| break; |
| } |
| |
| // pc/ln table bounds |
| p = pclntab; |
| ep = epclntab; |
| |
| f = func; |
| ef = func + nfunc; |
| pc = func[0].entry; // text base |
| f->pcln.array = p; |
| f->pc0 = pc; |
| line = 0; |
| for(;;) { |
| while(p < ep && *p > 128) |
| pc += pcquant * (*p++ - 128); |
| // runtime·printf("pc<%p targetpc=%p line=%d\n", pc, targetpc, line); |
| if(*p == 0) { |
| if(p+5 > ep) |
| break; |
| // 4 byte add to line |
| line += (p[1]<<24) | (p[2]<<16) | (p[3]<<8) | p[4]; |
| p += 5; |
| } else if(*p <= 64) |
| line += *p++; |
| else |
| line -= *p++ - 64; |
| |
| // pc, line now match. |
| // Because the state machine begins at pc==entry and line==0, |
| // it can happen - just at the beginning! - that the update may |
| // have updated line but left pc alone, to tell us the true line |
| // number for pc==entry. In that case, update f->ln0. |
| // Having the correct initial line number is important for choosing |
| // the correct file in dosrcline above. |
| if(f == func && pc == f->pc0) { |
| f->pcln.array = p; |
| f->pc0 = pc + pcquant; |
| f->ln0 = line; |
| } |
| |
| if(f < ef && pc >= (f+1)->entry) { |
| f->pcln.len = p - f->pcln.array; |
| f->pcln.cap = f->pcln.len; |
| do |
| f++; |
| while(f < ef && pc >= (f+1)->entry); |
| f->pcln.array = p; |
| // pc0 and ln0 are the starting values for |
| // the loop over f->pcln, so pc must be |
| // adjusted by the same pcquant update |
| // that we're going to do as we continue our loop. |
| f->pc0 = pc + pcquant; |
| f->ln0 = line; |
| } |
| |
| pc += pcquant; |
| } |
| if(f < ef) { |
| f->pcln.len = p - f->pcln.array; |
| f->pcln.cap = f->pcln.len; |
| } |
| } |
| |
| |
| // Return actual file line number for targetpc in func f. |
| // (Source file is f->src.) |
| // NOTE(rsc): If you edit this function, also edit extern.go:/FileLine |
| int32 |
| runtime·funcline(Func *f, uintptr targetpc) |
| { |
| byte *p, *ep; |
| uintptr pc; |
| int32 line; |
| int32 pcquant; |
| |
| enum { |
| debug = 0 |
| }; |
| |
| switch(thechar) { |
| case '5': |
| pcquant = 4; |
| break; |
| default: // 6, 8 |
| pcquant = 1; |
| break; |
| } |
| |
| p = f->pcln.array; |
| ep = p + f->pcln.len; |
| pc = f->pc0; |
| line = f->ln0; |
| if(debug && !runtime·panicking) |
| runtime·printf("funcline start pc=%p targetpc=%p line=%d tab=%p+%d\n", |
| pc, targetpc, line, p, (int32)f->pcln.len); |
| for(;;) { |
| // Table is a sequence of updates. |
| |
| // Each update says first how to adjust the pc, |
| // in possibly multiple instructions... |
| while(p < ep && *p > 128) |
| pc += pcquant * (*p++ - 128); |
| |
| if(debug && !runtime·panicking) |
| runtime·printf("pc<%p targetpc=%p line=%d\n", pc, targetpc, line); |
| |
| // If the pc has advanced too far or we're out of data, |
| // stop and the last known line number. |
| if(pc > targetpc || p >= ep) |
| break; |
| |
| // ... and then how to adjust the line number, |
| // in a single instruction. |
| if(*p == 0) { |
| if(p+5 > ep) |
| break; |
| line += (p[1]<<24) | (p[2]<<16) | (p[3]<<8) | p[4]; |
| p += 5; |
| } else if(*p <= 64) |
| line += *p++; |
| else |
| line -= *p++ - 64; |
| // Now pc, line pair is consistent. |
| if(debug && !runtime·panicking) |
| runtime·printf("pc=%p targetpc=%p line=%d\n", pc, targetpc, line); |
| |
| // PC increments implicitly on each iteration. |
| pc += pcquant; |
| } |
| return line; |
| } |
| |
| void |
| runtime·funcline_go(Func *f, uintptr targetpc, String retfile, intgo retline) |
| { |
| retfile = f->src; |
| retline = runtime·funcline(f, targetpc); |
| FLUSH(&retfile); |
| FLUSH(&retline); |
| } |
| |
| static void |
| buildfuncs(void) |
| { |
| extern byte etext[]; |
| |
| if(func != nil) |
| return; |
| |
| // Memory profiling uses this code; |
| // can deadlock if the profiler ends |
| // up back here. |
| m->nomemprof++; |
| |
| // count funcs, fnames |
| nfunc = 0; |
| nfname = 0; |
| lastvalue = 0; |
| walksymtab(dofunc); |
| |
| // Initialize tables. |
| // Can use FlagNoPointers - all pointers either point into sections of the executable |
| // or point into hugestring. |
| func = runtime·mallocgc((nfunc+1)*sizeof func[0], FlagNoPointers, 0, 1); |
| func[nfunc].entry = (uint64)etext; |
| fname = runtime·mallocgc(nfname*sizeof fname[0], FlagNoPointers, 0, 1); |
| nfunc = 0; |
| lastvalue = 0; |
| walksymtab(dofunc); |
| |
| // split pc/ln table by func |
| splitpcln(); |
| |
| // record src file and line info for each func |
| walksymtab(dosrcline); // pass 1: determine hugestring_len |
| hugestring.str = runtime·mallocgc(hugestring_len, FlagNoPointers, 0, 0); |
| hugestring.len = 0; |
| walksymtab(dosrcline); // pass 2: fill and use hugestring |
| |
| if(hugestring.len != hugestring_len) |
| runtime·throw("buildfunc: problem in initialization procedure"); |
| |
| m->nomemprof--; |
| } |
| |
| Func* |
| runtime·findfunc(uintptr addr) |
| { |
| Func *f; |
| int32 nf, n; |
| |
| // Use atomic double-checked locking, |
| // because when called from pprof signal |
| // handler, findfunc must run without |
| // grabbing any locks. |
| // (Before enabling the signal handler, |
| // SetCPUProfileRate calls findfunc to trigger |
| // the initialization outside the handler.) |
| // Avoid deadlock on fault during malloc |
| // by not calling buildfuncs if we're already in malloc. |
| if(!m->mallocing && !m->gcing) { |
| if(runtime·atomicload(&funcinit) == 0) { |
| runtime·lock(&funclock); |
| if(funcinit == 0) { |
| buildfuncs(); |
| runtime·atomicstore(&funcinit, 1); |
| } |
| runtime·unlock(&funclock); |
| } |
| } |
| |
| if(nfunc == 0) |
| return nil; |
| if(addr < func[0].entry || addr >= func[nfunc].entry) |
| return nil; |
| |
| // binary search to find func with entry <= addr. |
| f = func; |
| nf = nfunc; |
| while(nf > 0) { |
| n = nf/2; |
| if(f[n].entry <= addr && addr < f[n+1].entry) |
| return &f[n]; |
| else if(addr < f[n].entry) |
| nf = n; |
| else { |
| f += n+1; |
| nf -= n+1; |
| } |
| } |
| |
| // can't get here -- we already checked above |
| // that the address was in the table bounds. |
| // this can only happen if the table isn't sorted |
| // by address or if the binary search above is buggy. |
| runtime·prints("findfunc unreachable\n"); |
| return nil; |
| } |
| |
| static bool |
| hasprefix(String s, int8 *p) |
| { |
| int32 i; |
| |
| for(i=0; i<s.len; i++) { |
| if(p[i] == 0) |
| return 1; |
| if(p[i] != s.str[i]) |
| return 0; |
| } |
| return p[i] == 0; |
| } |
| |
| static bool |
| contains(String s, int8 *p) |
| { |
| int32 i; |
| |
| if(p[0] == 0) |
| return 1; |
| for(i=0; i<s.len; i++) { |
| if(s.str[i] != p[0]) |
| continue; |
| if(hasprefix((String){s.str + i, s.len - i}, p)) |
| return 1; |
| } |
| return 0; |
| } |
| |
| bool |
| runtime·showframe(Func *f, bool current) |
| { |
| static int32 traceback = -1; |
| |
| if(current && m->throwing > 0) |
| return 1; |
| if(traceback < 0) |
| traceback = runtime·gotraceback(nil); |
| return traceback > 1 || f != nil && contains(f->name, ".") && !hasprefix(f->name, "runtime."); |
| } |