/* 
 * 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
 */ 

#define _GNU_SOURCE

#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>

#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.
 */

#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

#define USE_DLADDR

#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>

/* How many chars to reserve (on avg) for a line of output */
#define MAXSYMLEN 500

#ifdef  USE_MMAP
#include <sys/mman.h>
#endif /* USE_MMAP     */

#endif /* USE_ELF      */

#else  /* RTLD_DEFAULT */
#undef  USE_ELF
#endif /* RTLD_DEFAULT */

/* Forward Declaration */
#define NO_OFF ((unsigned long)-1L)

static ssize_t
symDump(char *buf, size_t buf_sz, void *addr, const char *fnam, const char *snam, unsigned long off);

#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;

/* LOCKING NOTE: if the ELF symbol facility is ever expanded to be truly used
 * in a multithreaded way then proper multiple-readers, single-writer locking
 * should be implemented:
 *    - elfsLockWrite() must block until all readers have left
 *    - elfsLockRead()  must block until writer has left.
 *    - elfsLockConvertWriteRead() atomically converts writer holding the
 *      writer's lock into a reader.
 * Right now we just use a single, global lock (for the stack trace) since we
 * only need to guard against multiple threads dumping stacks simultaneously and
 * we do not lock the symbol table(s) at all.
 */

/* Linked list where we keep all our ESyms */
static ESyms             elfs       = 0;

static void
elfsLockWrite()
{
    /* Only a single writer can hold this while no readers are active */
}

static void
elfsUnlockWrite()
{
    /* Must wake up readers blocking in elfsLockRead()                */
}

static void
elfsLockConvertWriteRead()
{
    /* Must atomically convert a writer into a reader, i.e., unlock
     * the writer's lock and atomically acquire the reader's lock
     */
}

static void
elfsLockRead()
{
    /* Multiple readers can hold this while the writer is not active  */
}

static void
elfsUnlockRead()
{
    /* Must wake up a (single) writer blocking in elfsLockWrite       */
}

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;
}

/* 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;

    elfsLockWrite();
    while ( (es = elfs) ) {
        elfs = es->next; 
        es->next = 0; /* paranoia */
        elfSymsDestroy(es);
    }
    elfsUnlockWrite();

}

static ESyms
elfSymsFind(const char *fname)
{
ESyms es;
    for ( es=elfs; es && strcmp(fname, es->fname); es = es->next )
        /* nothing else to do */; 
    return es;
}
#endif /* USE_ELF */

#ifdef USE_DLADDR

static ssize_t
elfLookupAddr(void *addr, char *buf, size_t buf_sz)
{
Dl_info    inf;
ssize_t    rval;

#ifdef USE_ELF
ESyms      es,nes;
uintptr_t  minoff,off;
int        i;
Sym        sym;
Sym        nearest;
const char *strtab;
uint8_t    c;
size_t     idx;
#endif

    if ( ! dladdr(addr, &inf) || (!inf.dli_fname && !inf.dli_sname) ) {
        /* unable to lookup   */
        return symDump(buf, buf_sz, addr, 0, 0, NO_OFF);
    }

    if ( inf.dli_sname ) {
        /* Have a symbol name - just use it and be done */
        return symDump(buf, buf_sz, addr, inf.dli_fname, inf.dli_sname, (unsigned long)(addr - inf.dli_saddr));
    }

#ifndef USE_ELF

    rval = symDump(buf, buf_sz, addr, inf.dli_fname, 0, NO_OFF);

#else

    /* No symbol info; try to access ELF file and ready symbol table from there */

    elfsLockRead();

    /* See if we have loaded this file already */
    es = elfSymsFind(inf.dli_fname);

    if ( !es ) {
        elfsUnlockRead();

        if ( ! (nes = elfRead(inf.dli_fname, (uintptr_t)inf.dli_fbase)) )  {
            /* this path can only be taken if there is no memory for '*nes' */
            if ( buf && buf_sz > 0 )
                *buf = 0;
            return 0;
        }

        elfsLockWrite();

        /* Has someone else intervened and already added this file while we were reading ? */
        es = elfSymsFind(inf.dli_fname);

        if ( es ) {
            /* undo our work in the unlikely event... */
            elfSymsDestroy( nes );
        } else {
            nes->next = elfs;
            es = elfs = nes;
        }
        elfsLockConvertWriteRead();
    }

    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 ) ) {
        rval = symDump(buf, buf_sz, addr, es->fname, strtab + idx, (unsigned long)minoff);
    } else {
        rval = symDump(buf, buf_sz, addr, es->fname, 0, NO_OFF);
    }

    elfsUnlockRead();

#endif /* USE_ELF */

    return rval;
}

#endif /* USE_DLADDR */

static epicsThreadOnceId stackTraceInitId = EPICS_THREAD_ONCE_INIT;
static epicsMutexId      stackTraceMtx;

static void stackTraceInit(void *unused)
{
    stackTraceMtx = epicsMutexMustCreate();
}

static void stackTraceLock(void)
{
    epicsThreadOnce( &stackTraceInitId, stackTraceInit, 0 );
    epicsMutexLock( stackTraceMtx );
}

static void stackTraceUnlock(void)
{
    epicsMutexUnlock( stackTraceMtx );
}

static ssize_t
dump(char **buf, size_t *buf_sz, size_t *good, const char *fmt, ...)
{
va_list ap;
ssize_t rval, put;
    va_start(ap, fmt);
        if ( *buf ) {
            put = rval = vsnprintf(*buf, *buf_sz, fmt, ap);
            if ( put > *buf_sz )
                put = *buf_sz;
            *buf    += put;
            *buf_sz -= put;
        } else {
            rval = errlogVprintf(fmt, ap);
        }
    va_end(ap);
    if ( rval > 0 )
        *good += rval;
    return rval;
}


static ssize_t
symDump(char *buf, size_t buf_sz, void *addr, const char *fnam, const char *snam, unsigned long off)
{
size_t rval = 0;

    dump( &buf, &buf_sz, &rval, "[%*p]", sizeof(addr)*2 + 2, addr);
    if ( fnam ) {
        dump( &buf, &buf_sz, &rval, ": %s", fnam );
    }
    if ( snam ) {
        dump( &buf, &buf_sz, &rval, "(%s", snam );
        if ( NO_OFF != off ) {
            dump( &buf, &buf_sz, &rval, "+0x%lx", off);
        }
        dump( &buf, &buf_sz, &rval, ")" );
    }
    dump( &buf, &buf_sz, &rval, "\n");

    return rval;
}

epicsShareFunc void epicsStackTrace(void)
{
void **buf;
#ifndef USE_DLADDR
char **bts;
ssize_t pos, siz;
char   *ptr;
#endif
char   *btsl  = 0;
size_t btsl_sz = sizeof(*btsl)*MAXSYMLEN;
int    i,n;

    if ( ! (buf = malloc(sizeof(*buf) * MAXDEPTH))
         || ! (btsl = malloc(btsl_sz))
       ) {
        free(buf);
        errlogPrintf("epicsStackTrace(): not enough memory for backtrace\n");
        return;
    }

    n = backtrace(buf, MAXDEPTH);

    stackTraceLock();

    errlogPrintf("Dumping a stack trace of thread '%s':\n", epicsThreadGetNameSelf());

    errlogFlush();

    /* backtrace_symbols() only works for global symbols on linux.
     * If we have dladdr() and then we can actually lookup local
     * symbols, too.
     */
#ifdef USE_DLADDR
    for ( i=0; i<n; i++ ) {
        /* Somehow errlog doesn't like small, broken-up pieces of lines which is
         * why we assemble into the 'btsl' buffer and use a single errlogPrintf...
         */
        elfLookupAddr(buf[i], btsl, btsl_sz);
        errlogPrintf("%s", btsl);
    }
#ifdef USE_ELF
    elfSymsFlush();
#endif
#else
    if ( (bts = backtrace_symbols(buf, n)) ) {
        for ( i=0; i<n; i++ ) {
            /* We'd like to use a similar layout (prepending the address) */
            siz = btsl_sz;
            pos = symDump(btsl, siz, buf[i], 0, 0, 0);
            /* Kill '\n' */
            if ( pos > 0 )
                btsl[--pos] = 0;
            siz -= pos;
            if ( siz >= 3 ) {
                strcat(btsl, ": ");
                pos += 2;
                siz -= 2;
            }
            strncat(btsl + pos, bts[i], siz);
            /* wipe out the trailing address */
            if ( (ptr = strrchr(btsl, '[')) )
                *ptr = 0;
            errlogPrintf("%s\n", btsl);
        }
        free(bts);
    } else {
        /* failed to create symbolic information; just print addresses */
        for ( i=0; i<n; i++ ) {
            symDump(btsl, btsl_sz, buf[i], 0, 0, 0);
            errlogPrintf("%s", btsl);
        }
    }
#endif

    free(btsl);
    btsl = 0;

    errlogPrintf("\n");

    errlogFlush();

    stackTraceUnlock();

    free(buf);
}


epicsShareFunc int epicsStackTraceGetFeatures(void)
{
#if (STACKTRACE_DEBUG & 2)
    errlogPrintf("Configuration -- ELF: ");
#ifdef USE_ELF
    errlogPrintf("yes");
#else
    errlogPrintf("no");
#endif
    errlogPrintf(", MMAP: ");
#ifdef USE_MMAP
    errlogPrintf("yes");
#else
    errlogPrintf("no");
#endif
    errlogPrintf(", dladdr: ");
#ifdef USE_DLADDR
    errlogPrintf("yes");
#else
    errlogPrintf("no");
#endif
    errlogPrintf("\n");
#endif

    /* We are a bit conservative here. The actual
     * situation depends on how we are linked (something
     * we don't have under control at compilation time)
     * Linux' dladdr and backtrace_symbols find global symbols 
     * (not from dynamic libraries) when statically linked but
     * not when dynamically linked.
     * OTOH: for a stripped executable it is unlikely that
     * even the ELF reader is able to help much...
     */

#ifdef USE_ELF
    return  EPICS_STACKTRACE_LCL_SYMBOLS
          | EPICS_STACKTRACE_GBL_SYMBOLS
          | EPICS_STACKTRACE_DYN_SYMBOLS
          | EPICS_STACKTRACE_ADDRESSES;
#elif defined(__linux__) || defined(linux)
    return  EPICS_STACKTRACE_DYN_SYMBOLS
          | EPICS_STACKTRACE_ADDRESSES;
#else
    return  EPICS_STACKTRACE_LCL_SYMBOLS
          | EPICS_STACKTRACE_GBL_SYMBOLS
          | EPICS_STACKTRACE_DYN_SYMBOLS
          | EPICS_STACKTRACE_ADDRESSES;
#endif
}