sal/osl/unx/backtrace.c

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: backtrace.c,v $
  10  * $Revision: 1.15 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31
  32 #ifdef SOLARIS
  33
  34 #include <dlfcn.h>
  35 #include <pthread.h>
  36 #include <setjmp.h>
  37 #include <stdio.h>
  38 #include <sys/frame.h>
  39 #include "backtrace.h"
  40
  41 #if defined(SPARC)
  42
  43 #if defined IS_LP64
  44
  45 #define FRAME_PTR_OFFSET 1
  46 #define FRAME_OFFSET     0
  47 #define STACK_BIAS       0x7ff
  48
  49 #else
  50
  51 #define FRAME_PTR_OFFSET 1
  52 #define FRAME_OFFSET     0
  53 #define STACK_BIAS       0
  54
  55 #endif
  56
  57 #elif defined( INTEL )
  58
  59 #define FRAME_PTR_OFFSET 3
  60 #define FRAME_OFFSET     0
  61 #define STACK_BIAS       0
  62
  63 #else
  64
  65 #error Unknown Solaris target platform.
  66
  67 #endif /* defined SPARC or INTEL */
  68
  69
  70 int backtrace( void **buffer, int max_frames )
  71 {
  72     jmp_buf       ctx;
  73     long          fpval;
  74     struct frame *fp;
  75     int i;
  76
  77     /* flush register windows */
  78 #ifdef SPARC
  79     asm("ta 3");
  80 #endif
  81
  82     /* get stack- and framepointer */
  83     setjmp(ctx);
  84
  85     fpval = ((long*)(ctx))[FRAME_PTR_OFFSET];
  86     fp = (struct frame*)((char*)(fpval) + STACK_BIAS);
  87
  88     for (i = 0; (i < FRAME_OFFSET) && (fp != 0); i++)
  89         fp = (struct frame*)((char*)(fp->fr_savfp) + STACK_BIAS);
  90
  91     /* iterate through backtrace */
  92     for (i = 0; (fp != 0) && (fp->fr_savpc != 0) && (i < max_frames); i++)
  93     {
  94         /* saved (prev) frame */
  95         struct frame * prev = (struct frame*)((char*)(fp->fr_savfp) + STACK_BIAS);
  96
  97         /* store frame */
  98         *(buffer++) = (void*)(fp->fr_savpc);
  99
 100         /* prev frame (w/ stack growing top down) */
 101         fp = (prev > fp) ? prev : 0;
 102     }
 103
 104     /* return number of frames stored */
 105     return i;
 106 }
 107
 108 void backtrace_symbols_fd( void **buffer, int size, int fd )
 109 {
 110     FILE        *fp = fdopen( fd, "w" );
 111
 112     if ( fp )
 113     {
 114         void **pFramePtr;
 115
 116         for ( pFramePtr = buffer; size > 0 && pFramePtr && *pFramePtr; pFramePtr++, size-- )
 117         {
 118             Dl_info             dli;
 119             ptrdiff_t   offset;
 120
 121             if ( 0 != dladdr( *pFramePtr, &dli ) )
 122             {
 123                 if ( dli.dli_fname && dli.dli_fbase )
 124                 {
 125                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_fbase;
 126                     fprintf( fp, "%s+0x%x", dli.dli_fname, offset );
 127                 }
 128                 if ( dli.dli_sname && dli.dli_saddr )
 129                 {
 130                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_saddr;
 131                     fprintf( fp, "(%s+0x%x)", dli.dli_sname, offset );
 132                 }
 133             }
 134             fprintf( fp, "[0x%x]\n", *pFramePtr );
 135         }
 136
 137         fflush( fp );
 138         fclose( fp );
 139     }
 140 }
 141
 142 #endif /* defined SOLARIS */
 143
 144
 145 #if defined FREEBSD || defined NETBSD
 146 #include <dlfcn.h>
 147 #include <pthread.h>
 148 #include <setjmp.h>
 149 #include <stddef.h>
 150 #include <stdio.h>
 151 #include "backtrace.h"
 152
 153 #define FRAME_PTR_OFFSET 1
 154 #define FRAME_OFFSET 0
 155
 156 int backtrace( void **buffer, int max_frames )
 157 {
 158     struct frame *fp;
 159     jmp_buf ctx;
 160     int i;
 161     /* get stack- and framepointer */
 162     setjmp(ctx);
 163     fp = (struct frame*)(((size_t*)(ctx))[FRAME_PTR_OFFSET]);
 164     for ( i=0; (i<FRAME_OFFSET) && (fp!=0); i++)
 165         fp = fp->fr_savfp;
 166     /* iterate through backtrace */
 167     for (i=0; fp && fp->fr_savpc && i<max_frames; i++)
 168     {
 169         /* store frame */
 170         *(buffer++) = (void *)fp->fr_savpc;
 171         /* next frame */
 172         fp=fp->fr_savfp;
 173     }
 174     return i;
 175 }
 176
 177 void backtrace_symbols_fd( void **buffer, int size, int fd )
 178 {
 179     FILE        *fp = fdopen( fd, "w" );
 180
 181     if ( fp )
 182     {
 183         void **pFramePtr;
 184         for ( pFramePtr = buffer; size > 0 && pFramePtr && *pFramePtr; pFramePtr++, size-- )
 185         {
 186             Dl_info             dli;
 187             ptrdiff_t   offset;
 188
 189             if ( 0 != dladdr( *pFramePtr, &dli ) )
 190             {
 191                 if ( dli.dli_fname && dli.dli_fbase )
 192                 {
 193                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_fbase;
 194                     fprintf( fp, "%s+0x%x", dli.dli_fname, offset );
 195                 }
 196                 if ( dli.dli_sname && dli.dli_saddr )
 197                 {
 198                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_saddr;
 199                     fprintf( fp, "(%s+0x%x)", dli.dli_sname, offset );
 200                 }
 201             }
 202             fprintf( fp, "[0x%x]\n", *pFramePtr );
 203         }
 204         fflush( fp );
 205         fclose( fp );
 206     }
 207 }
 208 #endif /* defined FREEBSD */
 209
 210 #if defined(IRIX)
 211 #include <stdio.h>
 212 #include <rld_interface.h>
 213 #include <exception.h>
 214 #include <sys/signal.h>
 215 #include <unistd.h>
 216
 217 /* Need extra libs -lexc -ldwarf -lelf */
 218
 219 int backtrace( void **buffer, int max_frames )
 220 {
 221     struct sigcontext context;
 222     int i = 0;
 223
 224     memset(&context, 0, sizeof(struct sigcontext));
 225
 226     exc_setjmp(&context);
 227     while(context.sc_pc != 1 && i < max_frames) {
 228         exc_unwind(&context, 0);
 229         if(context.sc_pc != 1) {
 230             *(buffer++) = (void *)context.sc_pc;
 231             i++;
 232         }
 233     }
 234     return(i);
 235 }
 236
 237 void backtrace_symbols_fd( void **buffer, int size, int fd )
 238 {
 239     FILE        *fp = fdopen( fd, "w" );
 240     struct sigcontext context;
 241     char *name;
 242
 243     if ( fp ) {
 244         while(context.sc_pc!=1) {
 245             if(context.sc_pc != 1) {
 246                 exc_unwind_name(&context, 0, &name);
 247                 fprintf(fp, " 0x%012lx %.100s\n", context.sc_pc, name ? name : "<unknown function>");
 248                 free(name);
 249             }
 250         }
 251
 252         fflush( fp );
 253         fclose( fp );
 254     }
 255 }
 256 #endif /* defined IRIX */
 257
 258 #ifdef LINUX
 259
 260 #ifndef _GNU_SOURCE
 261 #define _GNU_SOURCE
 262 #endif
 263
 264 #include <dlfcn.h>
 265 #include <pthread.h>
 266 #include <setjmp.h>
 267 #include <stdio.h>
 268 #include "backtrace.h"
 269
 270 #if defined(SPARC)
 271
 272 #define FRAME_PTR_OFFSET 1
 273 #define FRAME_OFFSET 0
 274
 275 #else
 276
 277 #error Unknown Linux target platform.
 278
 279 #endif /* defined SPARC or INTEL */
 280
 281 typedef int ptrdiff_t;
 282
 283 int backtrace( void **buffer, int max_frames )
 284 {
 285     struct frame *fp;
 286     jmp_buf ctx;
 287     int i;
 288
 289     /* flush register windows */
 290 #ifdef SPARC
 291     asm("ta 3");
 292 #endif
 293     /* get stack- and framepointer */
 294     setjmp(ctx);
 295     fp = (struct frame*)(((size_t*)(ctx))[FRAME_PTR_OFFSET]);
 296     for ( i=0; (i<FRAME_OFFSET) && (fp!=0); i++)
 297         fp = fp->fr_savfp;
 298
 299     /* iterate through backtrace */
 300     for (i=0; fp && fp->fr_savpc && i<max_frames; i++)
 301     {
 302         /* store frame */
 303         *(buffer++) = (void *)fp->fr_savpc;
 304         /* next frame */
 305         fp=fp->fr_savfp;
 306     }
 307     return i;
 308 }
 309
 310 void backtrace_symbols_fd( void **buffer, int size, int fd )
 311 {
 312     FILE        *fp = fdopen( fd, "w" );
 313
 314     if ( fp )
 315     {
 316         void **pFramePtr;
 317
 318         for ( pFramePtr = buffer; size > 0 && pFramePtr && *pFramePtr; pFramePtr++, size-- )
 319         {
 320             Dl_info             dli;
 321             ptrdiff_t   offset;
 322
 323             if ( 0 != dladdr( *pFramePtr, &dli ) )
 324             {
 325                 if ( dli.dli_fname && dli.dli_fbase )
 326                 {
 327                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_fbase;
 328                     fprintf( fp, "%s+0x%x", dli.dli_fname, offset );
 329                 }
 330                 if ( dli.dli_sname && dli.dli_saddr )
 331                 {
 332                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_saddr;
 333                     fprintf( fp, "(%s+0x%x)", dli.dli_sname, offset );
 334                 }
 335             }
 336             fprintf( fp, "[0x%x]\n", *pFramePtr );
 337         }
 338
 339         fflush( fp );
 340         fclose( fp );
 341     }
 342 }
 343
 344 #endif /* defined LINUX */
 345
 346 #if defined( MACOSX )
 347
 348 #include <dlfcn.h>
 349 #include <stdio.h>
 350 #include "backtrace.h"
 351
 352 typedef unsigned         ptrdiff_t;
 353
 354 /* glib backtrace is only available on MacOsX 10.5 or higher
 355    so we do it on our own */
 356
 357 int backtrace( void **buffer, int max_frames )
 358 {
 359     void **frame = (void **)__builtin_frame_address(0);
 360     void **bp = ( void **)(*frame);
 361     void *ip = frame[1];
 362     int i;
 363
 364     for ( i = 0; bp && ip && i < max_frames; i++ )
 365     {
 366         *(buffer++) = ip;
 367
 368         ip = bp[1];
 369         bp = (void**)(bp[0]);
 370     }
 371
 372     return i;
 373 }
 374
 375
 376 void backtrace_symbols_fd( void **buffer, int size, int fd )
 377 {
 378     FILE        *fp = fdopen( fd, "w" );
 379
 380     if ( fp )
 381     {
 382         void **pFramePtr;
 383
 384         for ( pFramePtr = buffer; size > 0 && pFramePtr && *pFramePtr; pFramePtr++, size-- )
 385         {
 386             Dl_info             dli;
 387             ptrdiff_t   offset;
 388
 389             if ( 0 != dladdr( *pFramePtr, &dli ) )
 390             {
 391                 if ( dli.dli_fname && dli.dli_fbase )
 392                 {
 393                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_fbase;
 394                     fprintf( fp, "%s+0x%x", dli.dli_fname, offset );
 395                 }
 396                 if ( dli.dli_sname && dli.dli_saddr )
 397                 {
 398                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_saddr;
 399                     fprintf( fp, "(%s+0x%x)", dli.dli_sname, offset );
 400                 }
 401             }
 402             fprintf( fp, "[0x%x]\n", (unsigned int)*pFramePtr );
 403         }
 404
 405         fflush( fp );
 406         fclose( fp );
 407     }
 408 }
 409
 410 #endif /* defined MACOSX */