sysdeps/i386/backtrace.c

   1 /* Return backtrace of current program state.
   2    Copyright (C) 1998-2014 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <bits/libc-lock.h>
  21 #include <dlfcn.h>
  22 #include <execinfo.h>
  23 #include <stdlib.h>
  24 #include <unwind.h>
  25
  26 struct trace_arg
  27 {
  28   void **array;
  29   int cnt, size;
  30   void *lastebp, *lastesp;
  31 };
  32
  33 #ifdef SHARED
  34 static _Unwind_Reason_Code (*unwind_backtrace) (_Unwind_Trace_Fn, void *);
  35 static _Unwind_Ptr (*unwind_getip) (struct _Unwind_Context *);
  36 static _Unwind_Ptr (*unwind_getcfa) (struct _Unwind_Context *);
  37 static _Unwind_Ptr (*unwind_getgr) (struct _Unwind_Context *, int);
  38 static void *libgcc_handle;
  39
  40 static void
  41 init (void)
  42 {
  43   libgcc_handle = __libc_dlopen ("libgcc_s.so.1");
  44
  45   if (libgcc_handle == NULL)
  46     return;
  47
  48   unwind_backtrace = __libc_dlsym (libgcc_handle, "_Unwind_Backtrace");
  49   unwind_getip = __libc_dlsym (libgcc_handle, "_Unwind_GetIP");
  50   unwind_getcfa = __libc_dlsym (libgcc_handle, "_Unwind_GetCFA");
  51   unwind_getgr = __libc_dlsym (libgcc_handle, "_Unwind_GetGR");
  52   if (unwind_getip == NULL || unwind_getgr == NULL || unwind_getcfa == NULL)
  53     {
  54       unwind_backtrace = NULL;
  55       __libc_dlclose (libgcc_handle);
  56       libgcc_handle = NULL;
  57     }
  58 }
  59 #else
  60 # define unwind_backtrace _Unwind_Backtrace
  61 # define unwind_getip _Unwind_GetIP
  62 # define unwind_getcfa _Unwind_GetCFA
  63 # define unwind_getgr _Unwind_GetGR
  64 #endif
  65
  66 static _Unwind_Reason_Code
  67 backtrace_helper (struct _Unwind_Context *ctx, void *a)
  68 {
  69   struct trace_arg *arg = a;
  70
  71   /* We are first called with address in the __backtrace function.
  72      Skip it.  */
  73   if (arg->cnt != -1)
  74     arg->array[arg->cnt] = (void *) unwind_getip (ctx);
  75   if (++arg->cnt == arg->size)
  76     return _URC_END_OF_STACK;
  77
  78   /* %ebp is DWARF2 register 5 on IA-32.  */
  79   arg->lastebp = (void *) unwind_getgr (ctx, 5);
  80   arg->lastesp = (void *) unwind_getcfa (ctx);
  81   return _URC_NO_REASON;
  82 }
  83
  84
  85 /* This is a global variable set at program start time.  It marks the
  86    highest used stack address.  */
  87 extern void *__libc_stack_end;
  88
  89
  90 /* This is the stack layout we see with every stack frame
  91    if not compiled without frame pointer.
  92
  93             +-----------------+        +-----------------+
  94     %ebp -> | %ebp last frame--------> | %ebp last frame--->...
  95             |                 |        |                 |
  96             | return address  |        | return address  |
  97             +-----------------+        +-----------------+
  98
  99    First try as far to get as far as possible using
 100    _Unwind_Backtrace which handles -fomit-frame-pointer
 101    as well, but requires .eh_frame info.  Then fall back to
 102    walking the stack manually.  */
 103
 104 struct layout
 105 {
 106   struct layout *ebp;
 107   void *ret;
 108 };
 109
 110
 111 int
 112 __backtrace (array, size)
 113      void **array;
 114      int size;
 115 {
 116   struct trace_arg arg = { .array = array, .size = size, .cnt = -1 };
 117 #ifdef SHARED
 118   __libc_once_define (static, once);
 119
 120   __libc_once (once, init);
 121   if (unwind_backtrace == NULL)
 122     return 0;
 123 #endif
 124
 125   if (size >= 1)
 126     unwind_backtrace (backtrace_helper, &arg);
 127
 128   if (arg.cnt > 1 && arg.array[arg.cnt - 1] == NULL)
 129     --arg.cnt;
 130   else if (arg.cnt < size)
 131     {
 132       struct layout *ebp = (struct layout *) arg.lastebp;
 133
 134       while (arg.cnt < size)
 135         {
 136           /* Check for out of range.  */
 137           if ((void *) ebp < arg.lastesp || (void *) ebp > __libc_stack_end
 138               || ((long) ebp & 3))
 139             break;
 140
 141           array[arg.cnt++] = ebp->ret;
 142           ebp = ebp->ebp;
 143         }
 144     }
 145   return arg.cnt != -1 ? arg.cnt : 0;
 146 }
 147 weak_alias (__backtrace, backtrace)
 148 libc_hidden_def (__backtrace)
 149
 150
 151 #ifdef SHARED
 152 /* Free all resources if necessary.  */
 153 libc_freeres_fn (free_mem)
 154 {
 155   unwind_backtrace = NULL;
 156   if (libgcc_handle != NULL)
 157     {
 158       __libc_dlclose (libgcc_handle);
 159       libgcc_handle = NULL;
 160     }
 161 }
 162 #endif