StackTrace.cc

Go to the documentation of this file.

#if !defined(__APPLE__) && !defined(_GNU_SOURCE)
#  define _GNU_SOURCE // enable dladdr and getline
#endif

#include "StackTrace.h"
#include <unistd.h>

#if defined(__APPLE__) // need atos
#  if defined(STACKTRACE_USE_BACKTRACE)
#    include <execinfo.h> // to record the backtrace addresses
#  endif
// for display:
#  include </usr/include/util.h> // forkpty to make a pseudo-terminal for atos
#  include <termios.h> // set pseudo-terminal to raw mode
#  include <sys/select.h> // test whether atos has responded yet

#elif defined(STACKTRACE_USE_BACKTRACE)
#  include <execinfo.h> // to record the backtrace addresses
// for display:
#  include <dlfcn.h> // dladdr()
#  include <sys/param.h> // realpath()
#  include <errno.h>
#  if defined(__GNUC__) && defined(__cplusplus)
#    include <cxxabi.h> // demangling
#    include <string>
#  endif
#  if defined(__linux__)
#    include <sys/stat.h>
#  endif
#endif

#ifdef __cplusplus
#  include <cstdio>
#  include <cstdlib>
#  include <cstring>
#else
#  include <stdio.h>
#  include <stdlib.h>
#  include <string.h>
#endif

#ifdef ST_UNUSED 
#elif defined(__GNUC__) && __GNUC__>3
//! portable access to compiler hint not to warn if a function argument is ignored (goes in argument list)
# define ST_UNUSED(x) UNUSED_##x __attribute__((unused)) 
//! portable access to compiler hint not to warn if a function argument is ignored (goes at beginning of function body)
# define ST_BODY_UNUSED(x) /*no body necessary*/

#elif defined(__LCLINT__) 
//! portable access to compiler hint not to warn if a function argument is ignored (goes in argument list)
# define ST_UNUSED(x) /*@unused@*/ x 
//! portable access to compiler hint not to warn if a function argument is ignored (goes at beginning of function body)
# define ST_BODY_UNUSED(x) /*no body necessary*/

#else 
//! portable access to compiler hint not to warn if a function argument is ignored (goes in argument list)
# define ST_UNUSED(x) UNUSED_##x 
//! portable access to compiler hint not to warn if a function argument is ignored (goes at beginning of function body)
# define ST_BODY_UNUSED(x) (void)UNUSED_##x /* ugly hack to avoid warning */
#endif

#ifdef __cplusplus
namespace stacktrace {
#endif /* __cplusplus */

int unrollStackFrame(struct StackFrame* curFrame, struct StackFrame* nextFrame) {
  if(curFrame==NULL)
    return 0;
  curFrame->caller=NULL;
  if(nextFrame==NULL)
    return 0;
  

#ifdef STACKTRACE_USE_BACKTRACE
  
  if(curFrame->packedRA==NULL)
    return 0; // don't have current frame
  if(*curFrame->packedRAUsed<=curFrame->depth+1) {
    // last element
    if(curFrame!=nextFrame) {
      nextFrame->packedRA = NULL;
      nextFrame->packedRAUsed = nextFrame->packedRACap = NULL;
    }
  return 0;
  }
  if(curFrame!=nextFrame) {
    nextFrame->packedRA = curFrame->packedRA;
    nextFrame->packedRAUsed = curFrame->packedRAUsed;
    nextFrame->packedRACap = curFrame->packedRACap;
    nextFrame->depth = curFrame->depth; // will be incremented below
  }
  nextFrame->ra = (*nextFrame->packedRA)[++(nextFrame->depth)];
  curFrame->caller=nextFrame;
  return 1;
  
#else

  void* nsp=NULL;
  machineInstruction * nra=NULL;

#if defined(__i386__) || defined(__x86_64__) || defined(__amd64__)
  if(curFrame->sp==NULL)
    return 0;
  if(((void**)curFrame->sp)-1==NULL)
    return 0;
  nsp=((void***)curFrame->sp)[-1];
  if(nsp==NULL)
    return 0;
  nsp=(void**)nsp+1; //move from frame pointer to stack pointer of previous frame
  nra=*((machineInstruction**)curFrame->sp);
  if(nsp<=curFrame->sp) {
    fprintf(stderr,"stacktrace::unrollStackFrame(sp=%p,ra=%p) directed to invalid next frame: (sp=%p,ra=%p)\n",curFrame->sp,curFrame->ra,nsp,nra);
    return 0;
  }
#  ifdef DEBUG_STACKTRACE
  if(curFrame->debug)
    printf("( %p %p ) -> { %p %p }\n",curFrame->sp,curFrame->ra,nsp,nra);
  nextFrame->debug=curFrame->debug;
#  endif
  nextFrame->sp=nsp;
  nextFrame->ra=nra;
  curFrame->caller=nextFrame;
  return 1;
#endif
#ifdef __POWERPC__
  if(curFrame->sp==NULL)
    return 0;
  if(*(void**)curFrame->sp==NULL)
    return 0;
  nsp=*(void**)curFrame->sp;
  nra=((machineInstruction**)nsp)[2];
  if(nsp<=curFrame->sp) {
    fprintf(stderr,"stacktrace::unrollStackFrame(sp=%p,ra=%p) directed to invalid next frame: (sp=%p,ra=%p)\n",curFrame->sp,curFrame->ra,nsp,nra);
    return 0;
  }
#  ifdef DEBUG_STACKTRACE
  if(curFrame->debug)
    printf("( %p %p ) -> { %p %p }\n",curFrame->sp,curFrame->ra,nsp,nra);
  nextFrame->debug=curFrame->debug;
#  endif
  nextFrame->sp=nsp;
  nextFrame->ra=nra;
  curFrame->caller=nextFrame;
  return 1;
#endif
#if defined(__MIPSEL__) || defined(__MIPS__) /* we're running on PLATFORM_APERIOS */
  if(curFrame->sp==NULL)
    return 0;
  /* Have to scan through intructions being executed because stack pointer is not stored directly on the stack */
  machineInstruction * ins;
  const machineInstruction * INS_BASE=(const machineInstruction *)0x2000; // lowest valid memory address?
  
#ifdef __PIC__
  ins = reinterpret_cast<machineInstruction*>(curFrame->gp-curFrame->ra);
#else
  ins = curFrame->ra;
#endif
  // find previous return address
  for(; ins>=INS_BASE; ins--) {
    // gcc will always save the return address with the instruction
    //     sw ra, offset(sp)
    // 
    // the high word in this case is sw sp ra
    if ( ( *ins & 0xffff0000 ) == 0xafbf0000 )
    {
      // the low word is the offset from sp
      int offset = *ins & 0x000ffff;
      
      // in case things went horribly awry, don't deref the non-aligned ptr
      if (offset & 0x3)
        return 0;
      
      nra = *reinterpret_cast<machineInstruction**>((char*)curFrame->sp + offset);
      break; // now search for stack pointer
    }
    
    //it appears the aperios stub entry functions always begin with "ori  t0,ra,0x0"
    //if we hit one of these, return 0, because we can't unroll any more
    //(or at least, I don't know how it returns from these... there's no return statements!)
    if ( *ins  == 0x37e80000 ) {
#  ifdef DEBUG_STACKTRACE
      if(curFrame->debug)
        printf("( %p %p %p ) -> { kernel? }\n",curFrame->sp,curFrame->ra,curFrame->gp);
#  endif
      return 0;
    }
  }
  // find previous stack pointer
  for(; ins>=INS_BASE; ins--) {
    // gcc will always change the stack frame with the instruction
    //     addiu sp,sp,offset
    //
    // at the beginning of the function the offset will be negative since the stack grows 
    // from high to low addresses
    //
    // first check the high word which will be instruction + regs in this case (I-type)
    if ( ( *ins & 0xffff0000 ) == 0x27bd0000 ) {
      // the offset is in the low word. since we're finding occurrence at the start of the function,
      // it will be negative (increase stack size), so sign extend it
      int offset = ( *ins & 0x0000ffff ) | 0xffff0000;

      // in case things went horribly awry, don't deref the non-aligned ptr
      if (offset & 0x3)
        return 0;
      
      nsp = (char*)curFrame->sp - offset;
      break;
    }
  }
  
  
  if(ins>=INS_BASE) {
    if(nsp<=curFrame->sp) {
#ifdef __PIC__
      fprintf(stderr,"stacktrace::unrollStackFrame(sp=%p,ra=%p,gp=%p) directed to invalid next frame: (sp=%p,ra=%p,gp=%p)\n",curFrame->sp,(void*)curFrame->ra,(void*)curFrame->gp,nsp,nra,(void*)(reinterpret_cast<size_t*>(nsp)[4]));
#else
      fprintf(stderr,"stacktrace::unrollStackFrame(sp=%p,ra=%p) directed to invalid next frame: (sp=%p,ra=%p)\n",curFrame->sp,(void*)curFrame->ra,nsp,nra);
#endif
      return 0;
    }

#ifdef __PIC__
#  ifdef DEBUG_STACKTRACE
    if(curFrame->debug)
      printf("( %p %p %p ) -> { %p %p %p }\n",curFrame->sp,curFrame->ra,curFrame->gp,nsp,nra,reinterpret_cast<size_t*>(nsp)[4]);
    nextFrame->debug=curFrame->debug;
#  endif
    // I'm not actually sure this is a valid stop criteria, but in testing,
    // after this it seems to cross into some kind of kernel code.
    // (We get a really low gp (0x106), although a fairly normal nra, and then go bouncing
    // around in memory until we hit sp=0x80808080, ra=0x2700, which seems to be the 'real' last frame)
    //if(reinterpret_cast<size_t>(nra)>reinterpret_cast<size_t*>(nsp)[4])
    //return 0;
    //instead of this however, now we check for the ori t0,ra,0 statement, and reuse previous gp below
    
    nextFrame->sp=nsp;
    //not sure how valid this is either:
    if(reinterpret_cast<size_t>(nra)>reinterpret_cast<size_t*>(nsp)[4]) {
      nextFrame->gp = curFrame->gp;
    } else {
      nextFrame->gp = reinterpret_cast<size_t*>(nsp)[4]; // gp is stored 4 words from stack pointer
    }
    nextFrame->ra = nextFrame->gp-reinterpret_cast<size_t>(nra);
#else
#  ifdef DEBUG_STACKTRACE
    if(curFrame->debug)
      printf("( %p %p ) -> { %p %p }\n",curFrame->sp,curFrame->ra,nsp,nra);
    nextFrame->debug=curFrame->debug;
#  endif
    nextFrame->sp=nsp;
    nextFrame->ra=nra;
#endif /* __PIC__ */
    curFrame->caller=nextFrame;
    return 1;
  }
#ifdef __PIC__
#  ifdef DEBUG_STACKTRACE
  if(curFrame->debug)
    printf("( %p %p %p ) -> { %p %p --- }\n",curFrame->sp,curFrame->ra,curFrame->gp,nsp,nra);
#  endif
#else
#  ifdef DEBUG_STACKTRACE
  if(curFrame->debug)
    printf("( %p %p ) -> { %p %p }\n",curFrame->sp,curFrame->ra,nsp,nra);
#  endif
#endif
  return 0;
#endif
#endif /* backtrace */
}

#ifdef STACKTRACE_USE_BACKTRACE
static int growAlloc(struct StackFrame* frame) {
  void** r = (void**)realloc(*frame->packedRA, *frame->packedRACap * sizeof(void*) * 2);
  if(r==NULL)
    return 0;
  *frame->packedRACap *= 2;
  *frame->packedRA = r;
  return 1;
}
#endif

#ifdef STACKTRACE_USE_BACKTRACE
const size_t MIN_CAP=50;
static void allocBacktraceRegion(struct StackFrame* frame, size_t cap) {
  if(cap < MIN_CAP)
    cap=MIN_CAP;
  frame->packedRACap = (size_t*)malloc(sizeof(size_t));
  *frame->packedRACap = MIN_CAP;
  frame->packedRAUsed = (size_t*)malloc(sizeof(size_t));
  *frame->packedRAUsed = 0;
  frame->packedRA = (void***)malloc(sizeof(void**));
  *frame->packedRA = (void**)malloc(*frame->packedRACap * sizeof(void*));
  //printf("Allocated %p\n",*frame->packedRA);
}
  
static void freeBacktraceRegion(struct StackFrame* frame) {
  //printf("Freeing %p\n",*frame->packedRA);
  free(frame->packedRACap);
  frame->packedRACap = NULL;
  free(frame->packedRAUsed);
  frame->packedRAUsed = NULL;
  free(*frame->packedRA);
  *frame->packedRA=NULL;
  free(frame->packedRA);
  frame->packedRA=NULL;
}
#endif

void getCurrentStackFrame(struct StackFrame* frame) {
#ifdef STACKTRACE_USE_BACKTRACE

  // first call?  allocate the storage area
  if(frame->packedRA==NULL)
    allocBacktraceRegion(frame,MIN_CAP);
  
  // call backtrace, if we hit the capacity, grow the buffer and try again
  do {
    *frame->packedRAUsed = backtrace(*frame->packedRA, *frame->packedRACap);
  } while(*frame->packedRAUsed==*frame->packedRACap && growAlloc(frame));
  
  // if we used an oversized buffer, shrink it back down
  if(*frame->packedRACap > *frame->packedRAUsed*2 && *frame->packedRACap>MIN_CAP) {
    unsigned int newsize = *frame->packedRAUsed * 3 / 2;
    if(newsize < MIN_CAP)
      newsize = MIN_CAP;
    void** r = (void**)realloc(*frame->packedRA, newsize * sizeof(void*) * 2);
    if(r!=NULL) {
      *frame->packedRACap = newsize;
      *frame->packedRA = r;
    }
  }
  frame->depth=1;
  
#else
  
  void** csp=NULL;
  machineInstruction* cra=NULL;

#ifdef __POWERPC__
  __asm __volatile__ ("mr %0,r1" : "=r"(csp) ); // get the current stack pointer
  __asm __volatile__ ("mflr %0" : "=r"(cra) );  // get the current return address
#endif /* __POWERPC__ */
  
#if defined(__MIPSEL__) || defined(__MIPS__)
#ifdef __PIC__
  size_t cgp=0;
  __asm __volatile__ ("move %0,$gp" : "=r"(cgp) ); //get the gp register so we can compute link addresses
#endif /* __PIC__ */
  __asm __volatile__ ("move %0,$sp" : "=r"(csp) ); // get the current stack pointer
  __asm __volatile__ ("jal readepc; nop; readepc: move %0,$ra" : "=r"(cra) ); // get the current return address
#endif /* __MIPSEL__ */
  
#if defined(__i386__)
  __asm __volatile__ ("movl %%ebp,%0" : "=m"(csp) ); // get the caller's stack pointer
  csp++; //go back one to really be a stack pointer
  //__asm __volatile__ ("movl (%%esp),%0" : "=r"(cra) ); // get the caller's address
  cra=*((machineInstruction**)csp);
  csp=((void***)csp)[-1]+1;
#endif /* __i386__ */

// basically the same as i386, but movq instead of movl, and rbp instead of ebp
#if defined(__x86_64__) || defined(__amd64__)
  __asm __volatile__ ("movq %%rbp,%0" : "=m"(csp) ); // get the caller's stack pointer
  csp++; //go back one to really be a stack pointer
  //__asm __volatile__ ("movq (%%rsp),%0" : "=r"(cra) ); // get the caller's address
  cra=*((machineInstruction**)csp);
  csp=((void***)csp)[-1]+1;
#endif /* amd64/x86_64 */

  frame->sp=csp;
#if defined(__PIC__) && (defined(__MIPSEL__) || defined(__MIPS__))
  frame->ra=cgp-reinterpret_cast<size_t>(cra);
  frame->gp=cgp;
#else
  frame->ra=cra;
#endif /* __PIC__ */

#if !defined(__i386__) && !defined(__x86_64__) && !defined(__amd64__)
  //with ia-32 it was more convenient to directly provide caller, so don't need to unroll
  //otherwise we actually want to return *caller's* frame, so unroll once
  unrollStackFrame(frame,frame);
#endif /* not __i386__ */
#endif /* backtrace */
}

void freeStackTrace(struct StackFrame* frame) {
#ifdef STACKTRACE_USE_BACKTRACE
  if(frame!=NULL && frame->packedRA!=NULL) {
    freeBacktraceRegion(frame);
  }
#endif
  while(frame!=NULL) {
    struct StackFrame * next=frame->caller;
    free(frame);
    if(frame==next)
      return;
    frame=next;
  }
}

struct StackFrame* allocateStackTrace(unsigned int size) {
  struct StackFrame * frame=NULL;
  while(size--!=0) {
    struct StackFrame * prev = (struct StackFrame *)malloc(sizeof(struct StackFrame));
    memset(prev, 0, sizeof(*prev));
#ifdef STACKTRACE_USE_BACKTRACE
    if(frame==NULL) {
      allocBacktraceRegion(prev,size);
    } else {
      prev->packedRA = frame->packedRA;
      prev->packedRAUsed = frame->packedRAUsed;
      prev->packedRACap = frame->packedRACap;
    }
    prev->depth = size-1;
#endif
    prev->caller=frame;
    frame=prev;
  }
  return frame;
}


struct StackFrame * recordStackTrace(unsigned int limit/*=-1U*/, unsigned int skip/*=0*/) {
  if(limit==0)
    return NULL;
  struct StackFrame * cur = allocateStackTrace(1);
#ifdef DEBUG_STACKTRACE
  cur->debug=0;
#endif
  getCurrentStackFrame(cur);
  for(; skip!=0; skip--)
    if(!unrollStackFrame(cur,cur)) {
      freeStackTrace(cur);
      return NULL;
    }
  struct StackFrame * prev = (struct StackFrame *)malloc(sizeof(struct StackFrame));
  memset(prev, 0, sizeof(*prev));
#ifdef DEBUG_STACKTRACE
  prev->debug=0;
#endif
  
  //unroll once more for the current frame
  if(!unrollStackFrame(cur,prev)) {
    freeStackTrace(cur);
    return NULL;
  }
#ifdef STACKTRACE_USE_BACKTRACE
  memset(cur,0,sizeof(*cur)); // clear cur, prev is now responsible for packedRA allocation
#else
  cur->caller=NULL;
#endif
  freeStackTrace(cur);
  cur=prev;
  
  for(--limit; limit!=0; limit--) {
    struct StackFrame * next = (struct StackFrame *)malloc(sizeof(struct StackFrame));
    memset(next, 0, sizeof(*next));
#ifdef DEBUG_STACKTRACE
    next->debug=0;
#endif
    if(!unrollStackFrame(prev,next)) {
      // reached end of trace
      free(next);
      prev->caller=NULL; //denotes end was reached
      return cur;
    }
    prev=next;
  }
  // reaching here implies limit was reached
  prev->caller=prev; //denotes limit was reached
  return cur;
}

struct StackFrame * recordOverStackTrace(struct StackFrame* frame, unsigned int skip) {
  struct StackFrame * cur = allocateStackTrace(1);
#ifdef DEBUG_STACKTRACE
  cur->debug=0;
#endif
  if(frame==NULL)
    return frame;
  getCurrentStackFrame(cur);
  for(; skip!=0; skip--)
    if(!unrollStackFrame(cur,cur)) {
      freeStackTrace(cur);
      return frame;
  }
#ifdef STACKTRACE_USE_BACKTRACE
  if(frame->packedRA!=NULL)
    freeBacktraceRegion(frame);
#endif

  //unroll once more for the current frame
  if(!unrollStackFrame(cur,frame)) {
    freeStackTrace(cur);
    return NULL;
  }
#ifdef STACKTRACE_USE_BACKTRACE
  memset(cur,0,sizeof(*cur)); // clear cur, frame is now responsible for packedRA allocation
#else
  cur->caller=NULL;
#endif
  freeStackTrace(cur);

  struct StackFrame * ans;
  for(; frame->caller!=NULL && frame->caller!=frame; frame=frame->caller) {
    ans=frame->caller; //don't lose remainder of free list if we hit the end
    if(!unrollStackFrame(frame,frame->caller)) {
      return ans; // reached end of trace
    }
  }
  // reaching here implies limit was reached
  frame->caller=frame; //denotes limit was reached
  return NULL;
}
    
    
#ifdef __APPLE__
// use atos to do symbol lookup, can lookup non-dynamic symbols and also line numbers
/*! This function is more complicated than you'd expect because atos doesn't flush after each line,
 *  so plain pipe() or socketpair() won't work until we close the write side.  But the whole point is
 *  we want to keep atos around so we don't have to reprocess the symbol table over and over.
 *  What we wind up doing is using forkpty() to make a new pseudoterminal for atos to run in,
 *  and thus will use line-buffering for stdout, and then we can get each line. */
static void atosLookup(unsigned int depth, void* ra) {
  static int fd=-1;
  int isfirst=0;
  
  if(fd==-1) {
    struct termios opts;
    cfmakeraw(&opts); // have to set this first, otherwise queries echo until child kicks in
    pid_t child = forkpty(&fd,NULL,&opts,NULL);
    if(child<0) {
      perror("Could not forkpty for atos call");
      return;
    }
    if(child==0) {
      //sleep(3);
      char pidstr[50];
      snprintf(pidstr,50,"%d",getppid());
      execlp("atos","atos","-p",pidstr,(char*)0);
      //snprintf(pidstr,50,"atos -p %d",getppid());
      //execlp("sh","sh","-i","-c",pidstr,(char*)0);
      fprintf(stderr,"Could not exec atos for stack trace!\n");
      _exit(1);
    }
    isfirst=1;
    }

    {
    char q[50];
    size_t qlen = snprintf(q,50,"%p\n",ra);
    //printf("query: %.*s",50,q);
    write(fd,q,qlen);
  }
  
  if(isfirst) {
    // atos can take a while to parse symbol table on first request, which is why we leave it running
    // if we see a delay, explain what's going on...
    int err;
    struct timeval tv = {3,0};
    fd_set fds;
    FD_ZERO(&fds);
    FD_SET(fd,&fds);
    err = select(fd+1,&fds,NULL,NULL,&tv);
    if(err<0)
      perror("select for atos output");
    if(err==0) // timeout
      printf("Generating... first call takes some time for 'atos' to cache the symbol table.\n");
    }

        {
    const unsigned int MAXLINE=1024;
    char line[MAXLINE];
    size_t nread=0;
    char c='x';
    while(c!='\n' && nread<MAXLINE) {
      if(read(fd,&c,1)<=0) {
        fprintf(stderr,"Lost atos connection for stacktrace\n");
        close(fd);
        fd=-1;
        break;
        }
      //printf("Read %d\n",c);
      if(c!='\r')
        line[nread++]=c;
    }
    if(nread<MAXLINE)
      line[nread++]='\0';
    fprintf(stderr,"%4d %.*s",depth,MAXLINE,line);
    }
}
  
#elif defined(STACKTRACE_USE_BACKTRACE)
  
#  if defined(__GNUC__) && defined(__cplusplus)
  static std::string demangle(const std::string& name)
  {
    int status = 0;
    char *d = 0;
    std::string ret = name;
    try { if ((d = abi::__cxa_demangle(name.c_str(), 0, 0, &status))) ret = d; }
    catch(...) {  }
    std::free(d);
    return ret;
  }
#  endif
  
#  ifndef __linux__
// on bsd based systems, we have fgetln() instead of getline()
static int getline(char** s, size_t* len, FILE* f) {
  size_t _len;
  char * _s = fgetln(f,&_len);
  if(_s==NULL)
    return -1;
  if(*len<_len+1) {
    char * ns = (char*)realloc(*s,_len+1);
    if(ns==NULL)
      return -1;
    *s=ns;
  }
  memcpy(*s,_s,_len);
  (*s)[_len]='\0';
  return _len;
}
#  endif

static int addr2lineLookup(const char* const ex, const void* const off, char** srcfile, size_t* srcfilelen, char** func, size_t* funclen) {
  const char * cmdfmt = "addr2line -fe '%s' %p";
  const size_t cmdlen = snprintf(NULL,0,cmdfmt,ex,off)+1;
  char * cmd = (char*)malloc(cmdlen*sizeof(char));
  if(cmd==NULL) {
    fprintf(stderr,"[ERR Could not malloc addr2line command]\n");
    return -1;
  }
  const int cmdused = snprintf(cmd,cmdlen,cmdfmt,ex,off);
  if(cmdused<0) {
    perror("snprintf for addr2line command");
    free(cmd);
    return -1;
  }
  if((size_t)cmdused>=cmdlen) {
    fprintf(stderr, "[ERR addr2line command grew? %d vs %lu]\n",cmdused,(unsigned long)cmdlen);
    free(cmd);
    return -1;
  }
  FILE* look=popen(cmd,"r");
  free(cmd);
  if(look==NULL) {
    fprintf(stderr, "[Missing addr2line]\n");
    return -1;
  }
  if(getline(func,funclen,look)<=0) {
    pclose(look);
    return -1;
  }
  if(getline(srcfile,srcfilelen,look)<=0) {
    pclose(look);
    return -1;
  }
  pclose(look);
  char* nl = strrchr(*func,'\n');
  if(nl!=NULL)
    *nl='\0';
  nl = strrchr(*srcfile,'\n');
  if(nl!=NULL)
    *nl='\0';
  return 0;
}

static void displayRelPath(FILE* os, const char * wd, const char* path) {
  unsigned int same=0,i=0;
  for(i=0; path[i]!='\0'; ++i) {
    if(wd[i]=='/')
      same=i+1;
    else if(wd[i]=='\0') {
      same=i;
      break;
    } else if(wd[i]!=path[i])
      break;
  }
  if(wd[same]=='\0')
    ++same;
  else if(same>1) {
    // really want to be relative to source tree root, don't bother with ..'s
    /*for(i=same; wd[i]!='\0'; ++i)
      if(wd[i]=='/')
        fprintf(os,"../");
    fprintf(os,"../");*/
  }
  fprintf(os,"%s",&path[same]);
}
#endif

//! attempts to read symbol information and displays stack trace header
static void beginDisplay() {
#ifdef STACKTRACE_USE_BACKTRACE
  //fprintf(stderr,"Stack Trace:\n");
#elif defined(PLATFORM_APERIOS)
  fprintf(stderr,"Run trace_lookup:");
#elif defined(__APPLE__)
  fprintf(stderr,"backtrace_symbols() unavailable, try 'atos' to make human-readable backtrace (-p %d):",getpid());
#else
  fprintf(stderr,"backtrace_symbols() unavailable, try addr2line or tools/trace_lookup to make human-readable backtrace:");
#endif
}

#ifdef __APPLE__
static void displayStackFrame(unsigned int depth, const struct StackFrame* frame) {
  atosLookup(depth,(void*)frame->ra);
}
#elif defined(STACKTRACE_USE_BACKTRACE)
static void displayStackFrame(unsigned int depth, const struct StackFrame* frame) {
  void* ra = (void*)frame->ra;
  Dl_info sym;
  memset(&sym,0,sizeof(Dl_info));
  int dlres = dladdr(frame->ra, &sym);
  
  int isExe = (sym.dli_fname==NULL); // if lib unknown, assume static linkage, implies executable
#  ifdef __linux__
  // detect if /proc/self/exe points to sym.dli_fname
  if(!isExe && sym.dli_fname[0]!='\0') {
    struct stat exeStat;
    struct stat libStat;
    if(stat("/proc/self/exe",&exeStat)!=0) {
      perror(" stat /proc/self/exe");
    } else if(stat(sym.dli_fname,&libStat)!=0) {
      perror(" stat lib");
    } else {
      isExe = (exeStat.st_dev==libStat.st_dev && exeStat.st_ino==libStat.st_ino);
    }
  }
#  endif

  if(dlres==0 || sym.dli_sname==NULL) {
    if(sym.dli_fname==NULL || sym.dli_fname[0]=='\0') {
      fprintf(stderr,"%4d  [non-dynamic symbol @ %p]",depth,ra);
      fprintf(stderr," (has offset %p in unknown library)\n",sym.dli_fbase);
    } else {
      // use addr2line for static function lookup
      const void* const off = (isExe) ? ra : (void*)((size_t)ra-(size_t)sym.dli_fbase);
      char* srcfile=NULL, *func=NULL;
      size_t srcfilelen=0, funclen=0;
      if(addr2lineLookup(sym.dli_fname,off,&srcfile,&srcfilelen,&func,&funclen)==0) {
        fprintf(stderr,"%4d  %s",depth,(strlen(func)==0) ? "[unknown symbol]" : func);
        if(!isExe) {
          const char * base = strrchr(sym.dli_fname,'/');
          fprintf(stderr," (%s)",(base==NULL)?sym.dli_fname:base+1);
        }
        if(strcmp(srcfile,"??:0")!=0) {
          fprintf(stderr," ");
          char * wd = getcwd(NULL,0);
          if(wd==NULL) {
            perror("getcwd");
            return;
          }
          fprintf(stderr,"(");
          displayRelPath(stderr,wd,srcfile);
          fprintf(stderr,")");
          free(wd);
        }
        fprintf(stderr,"\n");
      }
      free(srcfile);
      free(func);
    }
    return;
  } else {
    const char * dispFmt="%4d  %s +%#lx";
#  ifdef __cplusplus
    fprintf(stderr,dispFmt,depth,demangle(sym.dli_sname).c_str(),(size_t)ra-(size_t)sym.dli_saddr);
#  else
    fprintf(stderr,dispFmt,depth,sym.dli_sname,(size_t)ra-(size_t)sym.dli_saddr);
#  endif
  }

  if(sym.dli_fname==NULL || sym.dli_fname[0]=='\0') {
    fprintf(stderr," (%p, offset %p in unknown lib)\n",ra,sym.dli_fbase);
    return;
  } else if(isExe) {
    // don't bother listing executable name, just show return address
    // ...or since the symbol name and offset imply the return address, just skip it
    //fprintf(stderr," (%p)",ra);
  } else {
    // ra is meaningless in dynamically loaded libraries... address space layout randomization (ASLR)
    // just show library name
    const char * base = strrchr(sym.dli_fname,'/');
    fprintf(stderr," (%s)",(base==NULL)?sym.dli_fname:base+1);
  }
  
  // now do file and line number lookup of function via addr2line
  const void* const off = (isExe) ? ra : (void*)((size_t)ra-(size_t)sym.dli_fbase);
  char* srcfile=NULL, *func=NULL;
  size_t srcfilelen=0, funclen=0;
  if(addr2lineLookup(sym.dli_fname,off,&srcfile,&srcfilelen,&func,&funclen)==0 && strcmp(srcfile,"??:0")!=0) {
    fprintf(stderr," ");
    char * wd = getcwd(NULL,0);
    if(wd==NULL) {
      perror("getcwd");
      return;
    }
    fprintf(stderr,"(");
    displayRelPath(stderr,wd,srcfile);
    fprintf(stderr,")");
    free(wd);
  }
  fprintf(stderr,"\n");
  free(srcfile);
  free(func);
}
#else
static void displayStackFrame(unsigned int ST_UNUSED(depth), const struct StackFrame* frame) {
  ST_BODY_UNUSED(depth);
  fprintf(stderr," %p",(void*)frame->ra);
}
#endif

//! releases symbol information used during display
static void completeDisplay(int isend) {
#if defined(STACKTRACE_USE_BACKTRACE)
#endif
  if(!isend)
    fprintf(stderr," ...\n");
}

void displayCurrentStackTrace(unsigned int limit/*=-1U*/, unsigned int skip/*=0*/) {
  struct StackFrame * cur = allocateStackTrace(1);
#ifdef DEBUG_STACKTRACE
  cur->debug=0;
#endif
  unsigned int i;
  int more;
  if(limit==0)
    return;
  getCurrentStackFrame(cur);
  //printf(" initial (%p\t%p\t%p)\n",cur.ra,cur.sp,*(void**)cur.sp);
  beginDisplay();
  for(; skip!=0; skip--) {
    if(!unrollStackFrame(cur,cur)) {
      completeDisplay(1);
      return;
    }
    //printf(" skip (%p\t%p\t%p)\n",cur.ra,cur.sp,*(void**)cur.sp);
  }
  for(i=0; (more=unrollStackFrame(cur,cur)) && i<limit; i++) {
    //printf(" out (%p\t%p\t%p)\n",cur.ra,cur.sp,*(void**)cur.sp);
    displayStackFrame(i,cur);
  }
  completeDisplay(!more);
  freeStackTrace(cur);
}

void displayStackTrace(const struct StackFrame* frame) {
  int i;
  beginDisplay();
  for(i=0; frame!=NULL && frame->caller!=frame; i++) {
    displayStackFrame(i,frame);
    frame=frame->caller;
  }
  if(frame!=NULL)
    displayStackFrame(i+1,frame);
  completeDisplay(frame==NULL);
}


#ifdef __cplusplus
}
#endif /* __cplusplus */

/*! @file
 * @brief Implements functionality for performing stack traces
 * @author ejt (Generalized and implementation for non-MIPS platforms)
 * @author Stuart Scandrett (original inspiration, Aperios/MIPS stack operations)
 */