Till Straumann
652 lines
16 KiB
C
652 lines
16 KiB
C
/*
|
|
* Copyright: Stanford University / SLAC National Laboratory.
|
|
*
|
|
* EPICS BASE is distributed subject to a Software License Agreement found
|
|
* in file LICENSE that is included with this distribution.
|
|
*
|
|
* Author: Till Straumann <strauman@slac.stanford.edu>, 2011, 2014
|
|
*/
|
|
|
|
#include "epicsStackTrace.h"
|
|
#include "epicsThread.h"
|
|
#include "epicsMutex.h"
|
|
#include <execinfo.h>
|
|
#include <errlog.h>
|
|
#include <stdlib.h>
|
|
#include <fcntl.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <stdint.h>
|
|
|
|
#define MAXDEPTH 100
|
|
|
|
#define STACKTRACE_DEBUG 0
|
|
|
|
/* Darwin and GNU have dladdr() but Darwin's backtrace_symbols()
|
|
* already prints local symbols, too, whereas linux' does not.
|
|
* Hence, on linux we want to use dladdr() and lookup static
|
|
* symbols in the ELF symbol table.
|
|
*/
|
|
#define __USE_GNU
|
|
|
|
#ifdef freebsd
|
|
/* Some freebsd versions seem to export dladdr() only if __BSD_VISIBLE */
|
|
#define __BSD_VISIBLE 1
|
|
#endif
|
|
|
|
#include <dlfcn.h>
|
|
|
|
/* Check if we actually have the gnu/darwin extensions */
|
|
#ifdef RTLD_DEFAULT
|
|
|
|
#if defined(__linux__) || defined(linux)
|
|
#define USE_ELF
|
|
#define USE_MMAP
|
|
#elif defined(freebsd)
|
|
#define USE_ELF
|
|
#define USE_MMAP
|
|
#endif
|
|
|
|
#ifdef USE_ELF
|
|
#include <elf.h>
|
|
#include <errno.h>
|
|
#include <inttypes.h>
|
|
|
|
#ifdef USE_MMAP
|
|
#include <sys/mman.h>
|
|
#endif /* USE_MMAP */
|
|
|
|
#endif /* USE_ELF */
|
|
|
|
#else /* RTLD_DEFAULT */
|
|
#undef USE_ELF
|
|
#endif /* RTLD_DEFAULT */
|
|
|
|
#ifdef USE_ELF
|
|
|
|
/* Macros to handle elf32 vs. elf64 access to unions etc. */
|
|
|
|
#define FLD(c,s,f) (ELFCLASS32==c ? s.e32.f : s.e64.f )
|
|
#define ARR(c,s,i,f) (ELFCLASS32==c ? s.e32[i].f : s.e64[i].f)
|
|
|
|
/* Elf header */
|
|
typedef union Ehdr_ {
|
|
Elf32_Ehdr e32;
|
|
Elf64_Ehdr e64;
|
|
} Ehdr;
|
|
|
|
/* Section header */
|
|
typedef union Shdr_ {
|
|
Elf32_Shdr e32;
|
|
Elf64_Shdr e64;
|
|
} Shdr;
|
|
|
|
/* Elf symbol */
|
|
typedef union Sym_ {
|
|
void *raw;
|
|
Elf32_Sym *e32;
|
|
Elf64_Sym *e64;
|
|
} Sym;
|
|
|
|
/* Memory mapped portion of a file; we must
|
|
* keep additional information because the
|
|
* map's starting address + length must be
|
|
* page-aligned (man mmap).
|
|
*/
|
|
typedef struct MMap_ {
|
|
void *addr;
|
|
off_t off; /* offset into the map where 'real' data start */
|
|
size_t len;
|
|
size_t max; /* max offset: legal data from addr+off .. addr+off+max-1 */
|
|
void (*freeMap)(struct MMap_*); /* 'method' to destroy the mapping */
|
|
} *MMap;
|
|
|
|
/* Structure describing symbol information
|
|
* contained in a file.
|
|
* We keep these around (so that the file
|
|
* doesn't have to be opened + parsed every
|
|
* time we do a lookup).
|
|
*/
|
|
typedef struct ESyms_ {
|
|
struct ESyms_ *next; /* linked list; one struct per executable */
|
|
const char *fname; /* file name */
|
|
int fd; /* file descriptor */
|
|
uintptr_t addr; /* address where file is loaded */
|
|
MMap symMap;
|
|
MMap strMap;
|
|
size_t nsyms;
|
|
uint8_t class;
|
|
} *ESyms;
|
|
|
|
/* Linked list where we keep all our ESyms */
|
|
static ESyms elfs = 0;
|
|
static epicsThreadOnceId elfsInitId = EPICS_THREAD_ONCE_INIT;
|
|
static epicsMutexId elfsMtx;
|
|
|
|
static void elfsInit(void *unused)
|
|
{
|
|
elfsMtx = epicsMutexMustCreate();
|
|
}
|
|
|
|
static void elfsLock(void)
|
|
{
|
|
epicsThreadOnce( &elfsInitId, elfsInit, 0 );
|
|
epicsMutexLock( elfsMtx );
|
|
}
|
|
|
|
static void elfsUnlock(void)
|
|
{
|
|
epicsMutexUnlock( elfsMtx );
|
|
}
|
|
|
|
|
|
static void
|
|
freeMap(MMap m)
|
|
{
|
|
if ( m ) {
|
|
m->freeMap(m);
|
|
free(m);
|
|
}
|
|
}
|
|
|
|
/* Helper to read exactly 'sz' bytes into 'buf'
|
|
* RETURNS: # chars read or negative value on error.
|
|
*/
|
|
static size_t
|
|
do_read(int fd, void *buf, size_t sz)
|
|
{
|
|
size_t got;
|
|
void *ptr=buf;
|
|
while ( sz > 0 ) {
|
|
if ( (got=read(fd,ptr,sz)) < 0 ) {
|
|
return got;
|
|
}
|
|
ptr+=got;
|
|
sz -=got;
|
|
}
|
|
return ptr-buf;
|
|
}
|
|
|
|
#ifdef USE_MMAP
|
|
|
|
/* Destructor for data that is mmap()ed */
|
|
static void
|
|
freeMapMmap(MMap m)
|
|
{
|
|
if ( MAP_FAILED != m->addr )
|
|
munmap( m->addr, m->len );
|
|
}
|
|
|
|
/* Obtain section data with mmap() */
|
|
static MMap
|
|
getscn(int fd, uint8_t c, Shdr *shdr_p)
|
|
{
|
|
size_t n;
|
|
MMap rval = 0;
|
|
size_t pgsz = sysconf(_SC_PAGESIZE);
|
|
|
|
if ( 0 == (n=FLD(c,(*shdr_p),sh_size)) ) {
|
|
errlogPrintf("elfRead - getscn() -- no section data\n");
|
|
goto bail;
|
|
}
|
|
|
|
if ( ! (rval = malloc(sizeof(*rval))) ) {
|
|
errlogPrintf("elfRead - getscn() -- no memory for section map\n");
|
|
goto bail;
|
|
}
|
|
|
|
rval->freeMap = freeMapMmap;
|
|
|
|
rval->off = FLD(c,(*shdr_p),sh_offset) & (pgsz-1);
|
|
rval->len = (n + rval->off + (pgsz - 1)) & ~(pgsz - 1);
|
|
rval->max = rval->len - rval->off;
|
|
|
|
if ( MAP_FAILED == (rval->addr = mmap(0, rval->len, PROT_READ, MAP_SHARED, fd, FLD(c,(*shdr_p),sh_offset) & ~(pgsz-1))) ) {
|
|
errlogPrintf("elfRead - getscn() -- mapping section contents: %s\n", strerror(errno));
|
|
goto bail;
|
|
}
|
|
|
|
return rval;
|
|
|
|
bail:
|
|
freeMap(rval);
|
|
return 0;
|
|
}
|
|
|
|
#else /* USE_MMAP */
|
|
|
|
/* Destructor for data that is read into a malloc()ed buffer */
|
|
static void
|
|
freeMapMalloc(MMap m)
|
|
{
|
|
free(m->addr);
|
|
}
|
|
|
|
/* Read section data into a malloc()ed buffer */
|
|
static MMap
|
|
getscn(int fd, uint8_t c, Shdr *shdr_p)
|
|
{
|
|
size_t n;
|
|
MMap rval = 0;
|
|
|
|
if ( 0 == (n=FLD(c,(*shdr_p),sh_size)) ) {
|
|
errlogPrintf("elfRead - getscn() -- no section data\n");
|
|
goto bail;
|
|
}
|
|
|
|
if ( ! (rval = malloc(sizeof(*rval))) ) {
|
|
errlogPrintf("elfRead - getscn() -- no memory for section map\n");
|
|
goto bail;
|
|
}
|
|
|
|
rval->freeMap = freeMapMalloc;
|
|
|
|
if ( ! (rval->addr = malloc(n)) ) {
|
|
errlogPrintf("elfRead - getscn() -- no memory for section data\n");
|
|
goto bail;
|
|
}
|
|
|
|
rval->off = 0;
|
|
rval->len = n;
|
|
rval->max = rval->len - rval->off;
|
|
|
|
/* seek to symbol table contents */
|
|
if ( (off_t)-1 == lseek(fd, FLD(c,(*shdr_p),sh_offset), SEEK_SET) ) {
|
|
errlogPrintf("elfRead - getscn() -- seeking to sh_offset: %s\n", strerror(errno));
|
|
goto bail;
|
|
}
|
|
|
|
if ( n != do_read(fd, rval->addr, n) ) {
|
|
errlogPrintf("elfRead - getscn() -- reading section contents: %s\n", strerror(errno));
|
|
goto bail;
|
|
}
|
|
|
|
return rval;
|
|
|
|
bail:
|
|
freeMap(rval);
|
|
return 0;
|
|
}
|
|
#endif /* USE_MMAP */
|
|
|
|
/* Release resources but keep filename so that
|
|
* a file w/o symbol table is not read over and over again.
|
|
*/
|
|
static void
|
|
elfSymsRelease(ESyms es)
|
|
{
|
|
if ( es ) {
|
|
freeMap(es->symMap);
|
|
es->symMap = 0;
|
|
freeMap(es->strMap);
|
|
es->strMap = 0;
|
|
if ( es->fd >= 0 )
|
|
close(es->fd);
|
|
es->fd = -1;
|
|
es->nsyms = 0;
|
|
}
|
|
}
|
|
|
|
static ESyms
|
|
elfRead(const char *fname, uintptr_t fbase)
|
|
{
|
|
int i,n;
|
|
Ehdr ehdr;
|
|
Shdr shdr;
|
|
uint8_t c;
|
|
ESyms es;
|
|
ssize_t idx;
|
|
const char *cp;
|
|
|
|
if ( !(es = malloc(sizeof(*es))) ) {
|
|
/* no memory -- give up */
|
|
return 0;
|
|
}
|
|
|
|
memset(es, 0, sizeof(*es));
|
|
es->fd = -1;
|
|
es->fname = fname;
|
|
|
|
if ( (es->fd = open(fname, O_RDONLY)) < 0 ) {
|
|
errlogPrintf("elfRead() -- unable to open file: %s\n", strerror(errno));
|
|
goto bail;
|
|
}
|
|
|
|
if ( EI_NIDENT != do_read(es->fd, &ehdr, EI_NIDENT) ) {
|
|
errlogPrintf("elfRead() -- unable to read ELF e_ident: %s\n", strerror(errno));
|
|
goto bail;
|
|
}
|
|
|
|
if ( ELFMAG0 != ehdr.e32.e_ident[EI_MAG0]
|
|
|| ELFMAG1 != ehdr.e32.e_ident[EI_MAG1]
|
|
|| ELFMAG2 != ehdr.e32.e_ident[EI_MAG2]
|
|
|| ELFMAG3 != ehdr.e32.e_ident[EI_MAG3] ) {
|
|
errlogPrintf("bad ELF magic number\n");
|
|
goto bail;
|
|
}
|
|
|
|
if ( EV_CURRENT != ehdr.e32.e_ident[EI_VERSION] ) {
|
|
errlogPrintf("bad ELF version\n");
|
|
goto bail;
|
|
}
|
|
|
|
switch ( (es->class = c = ehdr.e32.e_ident[EI_CLASS]) ) {
|
|
default:
|
|
errlogPrintf("bad ELF class\n");
|
|
goto bail;
|
|
|
|
case ELFCLASS32:
|
|
n = sizeof(Elf32_Ehdr);
|
|
break;
|
|
case ELFCLASS64:
|
|
n = sizeof(Elf64_Ehdr);
|
|
break;
|
|
}
|
|
n -= EI_NIDENT;
|
|
|
|
/* read rest */
|
|
if ( n != do_read(es->fd, ehdr.e32.e_ident + EI_NIDENT, n) ) {
|
|
errlogPrintf("elfRead() -- unable to read ELF ehdr: %s\n", strerror(errno));
|
|
goto bail;
|
|
}
|
|
|
|
/* seek to section header table */
|
|
if ( (off_t)-1 == lseek(es->fd, FLD(c,ehdr,e_shoff), SEEK_SET) ) {
|
|
errlogPrintf("elfRead() -- unable to seek to shoff: %s\n", strerror(errno));
|
|
goto bail;
|
|
}
|
|
|
|
n = ELFCLASS32 == c ? sizeof(shdr.e32) : sizeof(shdr.e64);
|
|
|
|
for ( i = 0; i<FLD(c,ehdr,e_shnum); i++ ) {
|
|
if ( n != do_read(es->fd, &shdr, n) ) {
|
|
errlogPrintf("elfRead() -- unable to read section header: %s\n", strerror(errno));
|
|
goto bail;
|
|
}
|
|
if ( SHT_SYMTAB == FLD(c,shdr,sh_type) )
|
|
break;
|
|
}
|
|
|
|
if ( i>=FLD(c,ehdr,e_shnum) ) {
|
|
errlogPrintf("elfRead() -- no symbol table found\n");
|
|
goto bail;
|
|
}
|
|
|
|
if ( 0 == (n=FLD(c,shdr,sh_size)) ) {
|
|
errlogPrintf("elfRead() -- no symbol table data\n");
|
|
goto bail;
|
|
}
|
|
|
|
if ( !(es->symMap = getscn(es->fd, c, &shdr)) ) {
|
|
errlogPrintf("elfRead() -- unable to read ELF symtab\n");
|
|
goto bail;
|
|
}
|
|
|
|
es->nsyms = n / (ELFCLASS32==c ? sizeof(Elf32_Sym) : sizeof(Elf64_Sym));
|
|
|
|
/* find and read string table */
|
|
|
|
n = ELFCLASS32 == c ? sizeof(shdr.e32) : sizeof(shdr.e64);
|
|
|
|
/* seek to section header table */
|
|
if ( (off_t)-1 == lseek(es->fd, FLD(c,ehdr,e_shoff) + n * FLD(c,shdr,sh_link), SEEK_SET) ) {
|
|
errlogPrintf("elfRead() -- unable to lseek to ELF e_shoff: %s\n", strerror(errno));
|
|
goto bail;
|
|
}
|
|
|
|
if ( n != do_read(es->fd, &shdr, n) ) {
|
|
errlogPrintf("elfRead() -- unable to read ELF strtab section header: %s\n", strerror(errno));
|
|
goto bail;
|
|
}
|
|
|
|
if ( !(es->strMap = getscn(es->fd,c,&shdr)) ) {
|
|
errlogPrintf("elfRead() -- unable to read ELF strtab\n");
|
|
goto bail;
|
|
}
|
|
|
|
/* Make sure there is a terminating NUL - unfortunately, memrchr is not portable */
|
|
cp = es->strMap->addr + es->strMap->off;
|
|
for ( idx = es->strMap->max - 1; i >= 0; i-- ) {
|
|
if ( !cp[i] )
|
|
break;
|
|
}
|
|
es->strMap->max = idx + 1;
|
|
|
|
switch ( FLD(c,ehdr,e_type) ) {
|
|
case ET_EXEC:
|
|
/* Symbols in an executable already has absolute addresses */
|
|
es->addr = 0;
|
|
break;
|
|
case ET_DYN:
|
|
/* Symbols in an shared library are relative to base address */
|
|
es->addr = fbase;
|
|
break;
|
|
default:
|
|
errlogPrintf("elfLookupAddr(): Unexpected ELF object file type %u\n", FLD(c,ehdr,e_type));
|
|
goto bail;
|
|
}
|
|
|
|
return es;
|
|
|
|
bail:
|
|
elfSymsRelease(es);
|
|
return es;
|
|
}
|
|
|
|
#if 0
|
|
/* IMPLEMENTATION IS INCORRECT:
|
|
* with only a single lock 'elfLookupAddr()' would
|
|
* have to hold that the entire time while accessing
|
|
* a symbol table. This is inefficient if there are
|
|
* multiple readers. A better implementation would
|
|
* use a 'multiple-readers/single-writer' type of lock
|
|
* to protect the symbol tables.
|
|
*
|
|
* ATM we simply don't support destroying the
|
|
* tables (after dumping a stack trace the process is
|
|
* likely to be terminated anyways).
|
|
*/
|
|
|
|
/* Destroy a cached ELF symbol table */
|
|
static void
|
|
elfSymsDestroy(ESyms es)
|
|
{
|
|
if ( es ) {
|
|
elfSymsRelease(es);
|
|
free(es);
|
|
}
|
|
}
|
|
|
|
/* Destroy all cached ELF symbol tables */
|
|
static void
|
|
elfSymsFlush()
|
|
{
|
|
ESyms es;
|
|
|
|
elfsLock();
|
|
while ( (es = elfs) ) {
|
|
elfs = es->next;
|
|
es->next = 0; /* paranoia */
|
|
elfSymsDestroy(es);
|
|
}
|
|
elfsUnlock();
|
|
|
|
}
|
|
#endif
|
|
|
|
static void
|
|
elfLookupAddr(void *addr)
|
|
{
|
|
Dl_info inf;
|
|
ESyms es;
|
|
uintptr_t minoff,off;
|
|
int i;
|
|
Sym sym;
|
|
Sym nearest;
|
|
const char *strtab;
|
|
uint8_t c;
|
|
size_t idx;
|
|
|
|
if ( ! dladdr(addr, &inf) || (!inf.dli_fname && !inf.dli_sname) ) {
|
|
/* unable to lookup */
|
|
errlogPrintf("[%p]\n", addr);
|
|
return;
|
|
}
|
|
|
|
if ( inf.dli_sname ) {
|
|
/* Have a symbol name - just use it and be done */
|
|
errlogPrintf("%s(%s+0x%lu): [%p]\n", inf.dli_fname ? inf.dli_fname : "", inf.dli_sname, addr - inf.dli_saddr, addr);
|
|
return;
|
|
}
|
|
|
|
/* No symbol info; try to access ELF file and ready symbol table from there */
|
|
|
|
elfsLock();
|
|
|
|
/* See if we have loaded this file already */
|
|
for ( es=elfs; es && strcmp(inf.dli_fname, es->fname); es = es->next )
|
|
/* nothing else to do */;
|
|
|
|
if ( !es ) {
|
|
if ( ! (es = elfRead(inf.dli_fname, (uintptr_t)inf.dli_fbase)) ) {
|
|
elfsUnlock();
|
|
/* this path can only be taken if there is no memory for '*es' */
|
|
return;
|
|
}
|
|
es->next = elfs;
|
|
elfs = es;
|
|
}
|
|
|
|
elfsUnlock();
|
|
|
|
nearest.raw = 0;
|
|
minoff = (uintptr_t)-1LL;
|
|
|
|
if ( es->nsyms ) {
|
|
c = es->class;
|
|
sym.raw = es->symMap->addr + es->symMap->off;
|
|
strtab = es->strMap->addr + es->strMap->off;
|
|
|
|
/* Do a brute-force search through the symbol table; if this is executed
|
|
* very often then it would be worthwhile constructing a sorted list of
|
|
* symbol addresses but for the stack trace we don't care...
|
|
*/
|
|
#if (STACKTRACE_DEBUG & 1)
|
|
printf("Looking for %p\n", addr);
|
|
#endif
|
|
|
|
if ( ELFCLASS32 == c ) {
|
|
for ( i=0; i<es->nsyms; i++ ) {
|
|
if ( STT_FUNC != ELF32_ST_TYPE(sym.e32[i].st_info) )
|
|
continue;
|
|
/* don't bother about undefined symbols */
|
|
if ( 0 == sym.e32[i].st_shndx )
|
|
continue;
|
|
#if (STACKTRACE_DEBUG & 1)
|
|
printf("Trying: %s (0x%lx)\n", strtab + sym.e32[i].st_name, (unsigned long)(sym.e32[i].st_value + es->addr));
|
|
#endif
|
|
if ( (uintptr_t)addr >= (uintptr_t)sym.e32[i].st_value + es->addr ) {
|
|
off = (uintptr_t)addr - ((uintptr_t)sym.e32[i].st_value + es->addr);
|
|
if ( off < minoff ) {
|
|
minoff = off;
|
|
nearest.e32 = &sym.e32[i];
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for ( i=0; i<es->nsyms; i++ ) {
|
|
if ( STT_FUNC != ELF64_ST_TYPE(sym.e64[i].st_info) )
|
|
continue;
|
|
/* don't bother about undefined symbols */
|
|
if ( 0 == sym.e64[i].st_shndx )
|
|
continue;
|
|
#if (STACKTRACE_DEBUG & 1)
|
|
printf("Trying: %s (0x%llx)\n", strtab + sym.e64[i].st_name, (unsigned long long)(sym.e64[i].st_value + es->addr));
|
|
#endif
|
|
if ( (uintptr_t)addr >= (uintptr_t)sym.e64[i].st_value + es->addr ) {
|
|
off = (uintptr_t)addr - ((uintptr_t)sym.e64[i].st_value + es->addr);
|
|
if ( off < minoff ) {
|
|
minoff = off;
|
|
nearest.e64 = &sym.e64[i];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( nearest.raw && ( (idx = ARR(c,nearest,0,st_name)) < es->strMap->max ) ) {
|
|
errlogPrintf("%s(%s+0x%"PRIxPTR"): [%p]\n", es->fname, strtab + idx, minoff, addr);
|
|
} else {
|
|
errlogPrintf("%s[%p]\n", es->fname, addr);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
epicsShareFunc void epicsStackTrace(void)
|
|
{
|
|
void **buf;
|
|
#ifndef USE_ELF
|
|
char **bts;
|
|
#endif
|
|
int i,n;
|
|
|
|
errlogPrintf("Dumping a stack trace:\n");
|
|
|
|
errlogFlush();
|
|
|
|
if ( ! (buf = malloc(sizeof(*buf) * MAXDEPTH)) ) {
|
|
errlogPrintf("epicsStackTrace(): not enough memory for backtrace\n");
|
|
return;
|
|
}
|
|
|
|
n = backtrace(buf, MAXDEPTH);
|
|
|
|
/* backtrace_symbols() only works for global symbols on linux.
|
|
* If we have dladdr() and then we can actually lookup local
|
|
* symbols, too.
|
|
*/
|
|
#ifdef USE_ELF
|
|
for ( i=0; i<n; i++ ) {
|
|
elfLookupAddr(buf[i]);
|
|
}
|
|
#if 0
|
|
elfSymsFlush();
|
|
#endif
|
|
#else
|
|
if ( (bts = backtrace_symbols(buf, n)) ) {
|
|
for ( i=0; i<n; i++ ) {
|
|
errlogPrintf("%s\n", bts[i]);
|
|
}
|
|
free(bts);
|
|
} else {
|
|
/* failed to create symbolic information; just print addresses */
|
|
for ( i=0; i<n; i++ ) {
|
|
errlogPrintf("[%p]\n", buf[i]);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
errlogPrintf("\n");
|
|
|
|
errlogFlush();
|
|
|
|
free(buf);
|
|
}
|
|
|
|
|
|
epicsShareFunc int epicsStackTraceGetFeatures(void)
|
|
{
|
|
#ifdef USE_ELF
|
|
return EPICS_STACKTRACE_LCL_SYMBOLS
|
|
| EPICS_STACKTRACE_GBL_SYMBOLS
|
|
| EPICS_STACKTRACE_ADDRESSES;
|
|
#elif defined(__linux__) || defined(linux)
|
|
return EPICS_STACKTRACE_GBL_SYMBOLS
|
|
EPICS_STACKTRACE_ADDRESSES;
|
|
#else
|
|
return EPICS_STACKTRACE_LCL_SYMBOLS
|
|
| EPICS_STACKTRACE_GBL_SYMBOLS
|
|
| EPICS_STACKTRACE_ADDRESSES;
|
|
#endif
|
|
}
|