headers/libs/libunwind/libunwind_i.h

   1 /* libunwind - a platform-independent unwind library
   2    Copyright (C) 2001-2005 Hewlett-Packard Co
   3    Copyright (C) 2007 David Mosberger-Tang
   4         Contributed by David Mosberger-Tang <dmosberger@gmail.com>
   5
   6 This file is part of libunwind.
   7
   8 Permission is hereby granted, free of charge, to any person obtaining
   9 a copy of this software and associated documentation files (the
  10 "Software"), to deal in the Software without restriction, including
  11 without limitation the rights to use, copy, modify, merge, publish,
  12 distribute, sublicense, and/or sell copies of the Software, and to
  13 permit persons to whom the Software is furnished to do so, subject to
  14 the following conditions:
  15
  16 The above copyright notice and this permission notice shall be
  17 included in all copies or substantial portions of the Software.
  18
  19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  22 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  23 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  24 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  25 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  */
  26
  27 /* This files contains libunwind-internal definitions which are
  28    subject to frequent change and are not to be exposed to
  29    libunwind-users.  */
  30
  31 #ifndef libunwind_i_h
  32 #define libunwind_i_h
  33
  34 #ifdef HAVE_CONFIG_H
  35 # include "config.h"
  36 #endif
  37
  38 #include "compiler.h"
  39
  40 #ifdef HAVE___THREAD
  41   /* For now, turn off per-thread caching.  It uses up too much TLS
  42      memory per thread even when the thread never uses libunwind at
  43      all.  */
  44 # undef HAVE___THREAD
  45 #endif
  46
  47 /* Platform-independent libunwind-internal declarations.  */
  48
  49 #include <sys/types.h>  /* HP-UX needs this before include of pthread.h */
  50
  51 #include <assert.h>
  52 #include <libunwind.h>
  53 #include <pthread.h>
  54 #include <signal.h>
  55 #include <stdlib.h>
  56 #include <string.h>
  57 #include <unistd.h>
  58 #include <sys/mman.h>
  59
  60 #if defined(HAVE_ELF_H)
  61 # include <elf.h>
  62 #elif defined(HAVE_SYS_ELF_H)
  63 # include <sys/elf.h>
  64 #else
  65 # error Could not locate <elf.h>
  66 #endif
  67
  68 #if defined(HAVE_ENDIAN_H)
  69 # include <endian.h>
  70 #elif defined(HAVE_SYS_ENDIAN_H)
  71 # include <sys/endian.h>
  72 #else
  73 # define __LITTLE_ENDIAN        1234
  74 # define __BIG_ENDIAN           4321
  75 # if defined(__hpux)
  76 #   define __BYTE_ORDER __BIG_ENDIAN
  77 # elif defined(__QNX__)
  78 #   if defined(__BIGENDIAN__)
  79 #     define __BYTE_ORDER __BIG_ENDIAN
  80 #   elif defined(__LITTLEENDIAN__)
  81 #     define __BYTE_ORDER __LITTLE_ENDIAN
  82 #   else
  83 #     error Host has unknown byte-order.
  84 #   endif
  85 # elif defined(__sun)
  86 #   define __BYTE_ORDER __LITTLE_ENDIAN
  87 # else
  88 #   error Host has unknown byte-order.
  89 # endif
  90 #endif
  91
  92 #if defined(HAVE__BUILTIN_UNREACHABLE)
  93 # define unreachable() __builtin_unreachable()
  94 #else
  95 # define unreachable() do { } while (1)
  96 #endif
  97
  98 #ifdef DEBUG
  99 # define UNW_DEBUG      1
 100 #else
 101 # define UNW_DEBUG      0
 102 #endif
 103
 104 /* Make it easy to write thread-safe code which may or may not be
 105    linked against libpthread.  The macros below can be used
 106    unconditionally and if -lpthread is around, they'll call the
 107    corresponding routines otherwise, they do nothing.  */
 108
 109 #pragma weak pthread_mutex_init
 110 #pragma weak pthread_mutex_lock
 111 #pragma weak pthread_mutex_unlock
 112
 113 #define mutex_init(l)                                                   \
 114         (pthread_mutex_init != NULL ? pthread_mutex_init ((l), NULL) : 0)
 115 #define mutex_lock(l)                                                   \
 116         (pthread_mutex_lock != NULL ? pthread_mutex_lock (l) : 0)
 117 #define mutex_unlock(l)                                                 \
 118         (pthread_mutex_unlock != NULL ? pthread_mutex_unlock (l) : 0)
 119
 120 #ifdef HAVE_ATOMIC_OPS_H
 121 # include <atomic_ops.h>
 122 static inline int
 123 cmpxchg_ptr (void *addr, void *old, void *new)
 124 {
 125   union
 126     {
 127       void *vp;
 128       AO_t *aop;
 129     }
 130   u;
 131
 132   u.vp = addr;
 133   return AO_compare_and_swap(u.aop, (AO_t) old, (AO_t) new);
 134 }
 135 # define fetch_and_add1(_ptr)           AO_fetch_and_add1(_ptr)
 136 # define fetch_and_add(_ptr, value)     AO_fetch_and_add(_ptr, value)
 137    /* GCC 3.2.0 on HP-UX crashes on cmpxchg_ptr() */
 138 #  if !(defined(__hpux) && __GNUC__ == 3 && __GNUC_MINOR__ == 2)
 139 #   define HAVE_CMPXCHG
 140 #  endif
 141 # define HAVE_FETCH_AND_ADD
 142 #elif defined(HAVE_SYNC_ATOMICS) || defined(HAVE_IA64INTRIN_H)
 143 # ifdef HAVE_IA64INTRIN_H
 144 #  include <ia64intrin.h>
 145 # endif
 146 static inline int
 147 cmpxchg_ptr (void *addr, void *old, void *new)
 148 {
 149   union
 150     {
 151       void *vp;
 152       long *vlp;
 153     }
 154   u;
 155
 156   u.vp = addr;
 157   return __sync_bool_compare_and_swap(u.vlp, (long) old, (long) new);
 158 }
 159 # define fetch_and_add1(_ptr)           __sync_fetch_and_add(_ptr, 1)
 160 # define fetch_and_add(_ptr, value)     __sync_fetch_and_add(_ptr, value)
 161 # define HAVE_CMPXCHG
 162 # define HAVE_FETCH_AND_ADD
 163 #endif
 164 #define atomic_read(ptr)        (*(ptr))
 165
 166 #define UNWI_OBJ(fn)      UNW_PASTE(UNW_PREFIX,UNW_PASTE(I,fn))
 167 #define UNWI_ARCH_OBJ(fn) UNW_PASTE(UNW_PASTE(UNW_PASTE(_UI,UNW_TARGET),_), fn)
 168
 169 #define unwi_full_mask    UNWI_ARCH_OBJ(full_mask)
 170
 171 /* Type of a mask that can be used to inhibit preemption.  At the
 172    userlevel, preemption is caused by signals and hence sigset_t is
 173    appropriate.  In constrast, the Linux kernel uses "unsigned long"
 174    to hold the processor "flags" instead.  */
 175 typedef sigset_t intrmask_t;
 176
 177 extern intrmask_t unwi_full_mask;
 178
 179 /* Silence compiler warnings about variables which are used only if libunwind
 180    is configured in a certain way */
 181 static inline void mark_as_used(void *v UNUSED) {
 182 }
 183
 184 #if defined(CONFIG_BLOCK_SIGNALS)
 185 # define SIGPROCMASK(how, new_mask, old_mask) \
 186   sigprocmask((how), (new_mask), (old_mask))
 187 #else
 188 # define SIGPROCMASK(how, new_mask, old_mask) mark_as_used(old_mask)
 189 #endif
 190
 191 /* Prefer adaptive mutexes if available */
 192 #ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
 193 #define UNW_PTHREAD_MUTEX_INITIALIZER PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
 194 #else
 195 #define UNW_PTHREAD_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
 196 #endif
 197
 198 #define define_lock(name) \
 199   pthread_mutex_t name = UNW_PTHREAD_MUTEX_INITIALIZER
 200 #define lock_init(l)            mutex_init (l)
 201 #define lock_acquire(l,m)                               \
 202 do {                                                    \
 203   SIGPROCMASK (SIG_SETMASK, &unwi_full_mask, &(m));     \
 204   mutex_lock (l);                                       \
 205 } while (0)
 206 #define lock_release(l,m)                       \
 207 do {                                            \
 208   mutex_unlock (l);                             \
 209   SIGPROCMASK (SIG_SETMASK, &(m), NULL);        \
 210 } while (0)
 211
 212 #define SOS_MEMORY_SIZE 16384   /* see src/mi/mempool.c */
 213
 214 #ifndef MAP_ANONYMOUS
 215 # define MAP_ANONYMOUS MAP_ANON
 216 #endif
 217 #define GET_MEMORY(mem, size)                                               \
 218 do {                                                                        \
 219   /* Hopefully, mmap() goes straight through to a system call stub...  */   \
 220   mem = mmap (NULL, size, PROT_READ | PROT_WRITE,                           \
 221               MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);                          \
 222   if (mem == MAP_FAILED)                                                    \
 223     mem = NULL;                                                             \
 224 } while (0)
 225
 226 #define unwi_find_dynamic_proc_info     UNWI_OBJ(find_dynamic_proc_info)
 227 #define unwi_extract_dynamic_proc_info  UNWI_OBJ(extract_dynamic_proc_info)
 228 #define unwi_put_dynamic_unwind_info    UNWI_OBJ(put_dynamic_unwind_info)
 229 #define unwi_dyn_remote_find_proc_info  UNWI_OBJ(dyn_remote_find_proc_info)
 230 #define unwi_dyn_remote_put_unwind_info UNWI_OBJ(dyn_remote_put_unwind_info)
 231 #define unwi_dyn_validate_cache         UNWI_OBJ(dyn_validate_cache)
 232
 233 extern int unwi_find_dynamic_proc_info (unw_addr_space_t as,
 234                                         unw_word_t ip,
 235                                         unw_proc_info_t *pi,
 236                                         int need_unwind_info, void *arg);
 237 extern int unwi_extract_dynamic_proc_info (unw_addr_space_t as,
 238                                            unw_word_t ip,
 239                                            unw_proc_info_t *pi,
 240                                            unw_dyn_info_t *di,
 241                                            int need_unwind_info,
 242                                            void *arg);
 243 extern void unwi_put_dynamic_unwind_info (unw_addr_space_t as,
 244                                           unw_proc_info_t *pi, void *arg);
 245
 246 /* These handle the remote (cross-address-space) case of accessing
 247    dynamic unwind info. */
 248
 249 extern int unwi_dyn_remote_find_proc_info (unw_addr_space_t as,
 250                                            unw_word_t ip,
 251                                            unw_proc_info_t *pi,
 252                                            int need_unwind_info,
 253                                            void *arg);
 254 extern void unwi_dyn_remote_put_unwind_info (unw_addr_space_t as,
 255                                              unw_proc_info_t *pi,
 256                                              void *arg);
 257 extern int unwi_dyn_validate_cache (unw_addr_space_t as, void *arg);
 258
 259 extern unw_dyn_info_list_t _U_dyn_info_list;
 260 extern pthread_mutex_t _U_dyn_info_list_lock;
 261
 262 #if UNW_DEBUG
 263 #define unwi_debug_level                UNWI_ARCH_OBJ(debug_level)
 264 extern long unwi_debug_level;
 265
 266 # include <stdio.h>
 267 # define Debug(level,format...)                                         \
 268 do {                                                                    \
 269   if (unwi_debug_level >= level)                                        \
 270     {                                                                   \
 271       int _n = level;                                                   \
 272       if (_n > 16)                                                      \
 273         _n = 16;                                                        \
 274       fprintf (stderr, "%*c>%s: ", _n, ' ', __FUNCTION__);              \
 275       fprintf (stderr, format);                                         \
 276     }                                                                   \
 277 } while (0)
 278 # define Dprintf(format...)         fprintf (stderr, format)
 279 #else
 280 # define Debug(level,format...)
 281 # define Dprintf(format...)
 282 #endif
 283
 284 static ALWAYS_INLINE int
 285 print_error (const char *string)
 286 {
 287   return write (2, string, strlen (string));
 288 }
 289
 290 #define mi_init         UNWI_ARCH_OBJ(mi_init)
 291
 292 extern void mi_init (void);     /* machine-independent initializations */
 293 extern unw_word_t _U_dyn_info_list_addr (void);
 294
 295 /* This is needed/used by ELF targets only.  */
 296
 297 struct elf_image
 298   {
 299     void *image;                /* pointer to mmap'd image */
 300     size_t size;                /* (file-) size of the image */
 301   };
 302
 303 struct elf_dyn_info
 304   {
 305     struct elf_image ei;
 306     unw_dyn_info_t di_cache;
 307     unw_dyn_info_t di_debug;    /* additional table info for .debug_frame */
 308 #if UNW_TARGET_IA64
 309     unw_dyn_info_t ktab;
 310 #endif
 311 #if UNW_TARGET_ARM
 312     unw_dyn_info_t di_arm;      /* additional table info for .ARM.exidx */
 313 #endif
 314   };
 315
 316 static inline void invalidate_edi (struct elf_dyn_info *edi)
 317 {
 318   if (edi->ei.image)
 319     munmap (edi->ei.image, edi->ei.size);
 320   memset (edi, 0, sizeof (*edi));
 321   edi->di_cache.format = -1;
 322   edi->di_debug.format = -1;
 323 #if UNW_TARGET_ARM
 324   edi->di_arm.format = -1;
 325 #endif
 326 }
 327
 328
 329 /* Provide a place holder for architecture to override for fast access
 330    to memory when known not to need to validate and know the access
 331    will be local to the process. A suitable override will improve
 332    unw_tdep_trace() performance in particular. */
 333 #define ACCESS_MEM_FAST(ret,validate,cur,addr,to) \
 334   do { (ret) = dwarf_get ((cur), DWARF_MEM_LOC ((cur), (addr)), &(to)); } \
 335   while (0)
 336
 337 /* Define GNU and processor specific values for the Phdr p_type field in case
 338    they aren't defined by <elf.h>.  */
 339 #ifndef PT_GNU_EH_FRAME
 340 # define PT_GNU_EH_FRAME        0x6474e550
 341 #endif /* !PT_GNU_EH_FRAME */
 342 #ifndef PT_ARM_EXIDX
 343 # define PT_ARM_EXIDX           0x70000001      /* ARM unwind segment */
 344 #endif /* !PT_ARM_EXIDX */
 345
 346 #include "tdep/libunwind_i.h"
 347
 348 #ifndef tdep_get_func_addr
 349 # define tdep_get_func_addr(as,addr,v)          (*(v) = addr, 0)
 350 #endif
 351
 352 #ifndef DWARF_VAL_LOC
 353 # define DWARF_IS_VAL_LOC(l)    0
 354 # define DWARF_VAL_LOC(c,v)     DWARF_NULL_LOC
 355 #endif
 356
 357 #define UNW_ALIGN(x,a) (((x)+(a)-1UL)&~((a)-1UL))
 358
 359 #endif /* libunwind_i_h */