sal/osl/unx/backtrace.c

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 #ifdef SOLARIS
  22
  23 #include <dlfcn.h>
  24 #include <pthread.h>
  25 #include <setjmp.h>
  26 #include <stdio.h>
  27 #include <sys/frame.h>
  28 #include "backtrace.h"
  29
  30 #if defined(SPARC)
  31
  32 #if defined IS_LP64
  33
  34 #define FRAME_PTR_OFFSET 1
  35 #define FRAME_OFFSET     0
  36 #define STACK_BIAS       0x7ff
  37
  38 #else
  39
  40 #define FRAME_PTR_OFFSET 1
  41 #define FRAME_OFFSET     0
  42 #define STACK_BIAS       0
  43
  44 #endif
  45
  46 #elif defined( INTEL )
  47
  48 #define FRAME_PTR_OFFSET 3
  49 #define FRAME_OFFSET     0
  50 #define STACK_BIAS       0
  51
  52 #else
  53
  54 #error Unknown Solaris target platform.
  55
  56 #endif /* defined SPARC or INTEL */
  57
  58
  59 int backtrace( void **buffer, int max_frames )
  60 {
  61     jmp_buf       ctx;
  62     long          fpval;
  63     struct frame *fp;
  64     int i;
  65
  66     /* flush register windows */
  67 #ifdef SPARC
  68     asm("ta 3");
  69 #endif
  70
  71     /* get stack- and framepointer */
  72     setjmp(ctx);
  73
  74     fpval = ((long*)(ctx))[FRAME_PTR_OFFSET];
  75     fp = (struct frame*)((char*)(fpval) + STACK_BIAS);
  76
  77     for (i = 0; (i < FRAME_OFFSET) && (fp != 0); i++)
  78         fp = (struct frame*)((char*)(fp->fr_savfp) + STACK_BIAS);
  79
  80     /* iterate through backtrace */
  81     for (i = 0; (fp != 0) && (fp->fr_savpc != 0) && (i < max_frames); i++)
  82     {
  83         /* saved (prev) frame */
  84         struct frame * prev = (struct frame*)((char*)(fp->fr_savfp) + STACK_BIAS);
  85
  86         /* store frame */
  87         *(buffer++) = (void*)(fp->fr_savpc);
  88
  89         /* prev frame (w/ stack growing top down) */
  90         fp = (prev > fp) ? prev : 0;
  91     }
  92
  93     /* return number of frames stored */
  94     return i;
  95 }
  96
  97 void backtrace_symbols_fd( void **buffer, int size, int fd )
  98 {
  99     FILE    *fp = fdopen( fd, "w" );
 100
 101     if ( fp )
 102     {
 103         void **pFramePtr;
 104
 105         for ( pFramePtr = buffer; size > 0 && pFramePtr && *pFramePtr; pFramePtr++, size-- )
 106         {
 107             Dl_info     dli;
 108             ptrdiff_t   offset;
 109
 110             if ( 0 != dladdr( *pFramePtr, &dli ) )
 111             {
 112                 if ( dli.dli_fname && dli.dli_fbase )
 113                 {
 114                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_fbase;
 115                     fprintf( fp, "%s+0x%x", dli.dli_fname, offset );
 116                 }
 117                 if ( dli.dli_sname && dli.dli_saddr )
 118                 {
 119                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_saddr;
 120                     fprintf( fp, "(%s+0x%x)", dli.dli_sname, offset );
 121                 }
 122             }
 123             fprintf( fp, "[0x%x]\n", *pFramePtr );
 124         }
 125
 126         fflush( fp );
 127         fclose( fp );
 128     }
 129 }
 130
 131 #endif /* defined SOLARIS */
 132
 133
 134 #if defined FREEBSD || defined NETBSD || defined OPENBSD || defined(DRAGONFLY)
 135 #include <dlfcn.h>
 136 #include <pthread.h>
 137 #include <setjmp.h>
 138 #include <stddef.h>
 139 #include <stdio.h>
 140 #include "backtrace.h"
 141
 142 #define FRAME_PTR_OFFSET 1
 143 #define FRAME_OFFSET 0
 144
 145 int backtrace( void **buffer, int max_frames )
 146 {
 147     struct frame *fp;
 148     jmp_buf ctx;
 149     int i;
 150     /* get stack- and framepointer */
 151     setjmp(ctx);
 152     fp = (struct frame*)(((size_t*)(ctx))[FRAME_PTR_OFFSET]);
 153     for ( i=0; (i<FRAME_OFFSET) && (fp!=0); i++)
 154         fp = fp->fr_savfp;
 155     /* iterate through backtrace */
 156     for (i=0; fp && fp->fr_savpc && i<max_frames; i++)
 157     {
 158         /* store frame */
 159         *(buffer++) = (void *)fp->fr_savpc;
 160         /* next frame */
 161         fp=fp->fr_savfp;
 162     }
 163     return i;
 164 }
 165
 166 void backtrace_symbols_fd( void **buffer, int size, int fd )
 167 {
 168     FILE    *fp = fdopen( fd, "w" );
 169
 170     if ( fp )
 171     {
 172         void **pFramePtr;
 173         for ( pFramePtr = buffer; size > 0 && pFramePtr && *pFramePtr; pFramePtr++, size-- )
 174         {
 175             Dl_info     dli;
 176             ptrdiff_t   offset;
 177
 178             if ( 0 != dladdr( *pFramePtr, &dli ) )
 179             {
 180                 if ( dli.dli_fname && dli.dli_fbase )
 181                 {
 182                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_fbase;
 183                     fprintf( fp, "%s+0x%x", dli.dli_fname, offset );
 184                 }
 185                 if ( dli.dli_sname && dli.dli_saddr )
 186                 {
 187                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_saddr;
 188                     fprintf( fp, "(%s+0x%x)", dli.dli_sname, offset );
 189                 }
 190             }
 191             fprintf( fp, "[0x%x]\n", *pFramePtr );
 192         }
 193         fflush( fp );
 194         fclose( fp );
 195     }
 196 }
 197 #endif /* defined FREEBSD */
 198
 199 #ifdef LINUX
 200
 201 #ifndef _GNU_SOURCE
 202 #define _GNU_SOURCE
 203 #endif
 204
 205 #endif /* defined LINUX */
 206
 207 #if defined( MACOSX )
 208
 209 #include <dlfcn.h>
 210 #include <stdio.h>
 211 #include "backtrace.h"
 212
 213 typedef unsigned     ptrdiff_t;
 214
 215 /* glib backtrace is only available on MacOsX 10.5 or higher
 216    so we do it on our own */
 217
 218 int backtrace( void **buffer, int max_frames )
 219 {
 220     void **frame = (void **)__builtin_frame_address(0);
 221     void **bp = ( void **)(*frame);
 222     void *ip = frame[1];
 223     int i;
 224
 225     for ( i = 0; bp && ip && i < max_frames; i++ )
 226     {
 227         *(buffer++) = ip;
 228
 229         ip = bp[1];
 230         bp = (void**)(bp[0]);
 231     }
 232
 233     return i;
 234 }
 235
 236
 237 void backtrace_symbols_fd( void **buffer, int size, int fd )
 238 {
 239     FILE    *fp = fdopen( fd, "w" );
 240
 241     if ( fp )
 242     {
 243         void **pFramePtr;
 244
 245         for ( pFramePtr = buffer; size > 0 && pFramePtr && *pFramePtr; pFramePtr++, size-- )
 246         {
 247             Dl_info     dli;
 248
 249             if ( 0 != dladdr( *pFramePtr, &dli ) )
 250             {
 251                 ptrdiff_t offset;
 252
 253                 if ( dli.dli_fname && dli.dli_fbase )
 254                 {
 255                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_fbase;
 256                     fprintf( fp, "%s+0x%x", dli.dli_fname, offset );
 257                 }
 258                 if ( dli.dli_sname && dli.dli_saddr )
 259                 {
 260                     offset = (ptrdiff_t)*pFramePtr - (ptrdiff_t)dli.dli_saddr;
 261                     fprintf( fp, "(%s+0x%x)", dli.dli_sname, offset );
 262                 }
 263             }
 264             fprintf( fp, "[0x%x]\n", (unsigned int)*pFramePtr );
 265         }
 266
 267         fflush( fp );
 268         fclose( fp );
 269     }
 270 }
 271
 272 #endif /* defined MACOSX */
 273
 274 #if defined(AIX)
 275 int backtrace( void **buffer, int max_frames )
 276 {
 277     return 0;
 278 }
 279
 280 void backtrace_symbols_fd( void **buffer, int size, int fd )
 281 {
 282 }
 283 #endif
 284
 285 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */