1//===------------------------- AddressSpace.hpp ---------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is dual licensed under the MIT and the University of Illinois Open
6// Source Licenses. See LICENSE.TXT for details.
7//
8//
9// Abstracts accessing local vs remote address spaces.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef __ADDRESSSPACE_HPP__
14#define __ADDRESSSPACE_HPP__
15
16#include <stdint.h>
17#include <stdio.h>
18#include <stdlib.h>
19#include <string.h>
20#include <dlfcn.h>
21
22#if __APPLE__
23#include <mach-o/getsect.h>
24namespace libunwind {
25   bool checkKeyMgrRegisteredFDEs(uintptr_t targetAddr, void *&fde);
26}
27#endif
28
29#include "libunwind.h"
30#include "config.h"
31#include "dwarf2.h"
32#include "Registers.hpp"
33
34#if LIBCXXABI_ARM_EHABI
35#if __linux__
36
37typedef long unsigned int *_Unwind_Ptr;
38extern "C" _Unwind_Ptr __gnu_Unwind_Find_exidx(_Unwind_Ptr addr, int *len);
39
40// Emulate the BSD dl_unwind_find_exidx API when on a GNU libdl system.
41#define dl_unwind_find_exidx __gnu_Unwind_Find_exidx
42
43#else
44#include <link.h>
45#endif
46#endif  // LIBCXXABI_ARM_EHABI
47
48namespace libunwind {
49
50/// Used by findUnwindSections() to return info about needed sections.
51struct UnwindInfoSections {
52#if _LIBUNWIND_SUPPORT_DWARF_UNWIND || _LIBUNWIND_SUPPORT_DWARF_INDEX ||       \
53    _LIBUNWIND_SUPPORT_COMPACT_UNWIND
54  // No dso_base for ARM EHABI.
55  uintptr_t       dso_base;
56#endif
57#if _LIBUNWIND_SUPPORT_DWARF_UNWIND
58  uintptr_t       dwarf_section;
59  uintptr_t       dwarf_section_length;
60#endif
61#if _LIBUNWIND_SUPPORT_DWARF_INDEX
62  uintptr_t       dwarf_index_section;
63  uintptr_t       dwarf_index_section_length;
64#endif
65#if _LIBUNWIND_SUPPORT_COMPACT_UNWIND
66  uintptr_t       compact_unwind_section;
67  uintptr_t       compact_unwind_section_length;
68#endif
69#if LIBCXXABI_ARM_EHABI
70  uintptr_t       arm_section;
71  uintptr_t       arm_section_length;
72#endif
73};
74
75
76/// LocalAddressSpace is used as a template parameter to UnwindCursor when
77/// unwinding a thread in the same process.  The wrappers compile away,
78/// making local unwinds fast.
79class __attribute__((visibility("hidden"))) LocalAddressSpace {
80public:
81#if __LP64__
82  typedef uint64_t pint_t;
83  typedef int64_t  sint_t;
84#else
85  typedef uint32_t pint_t;
86  typedef int32_t  sint_t;
87#endif
88  uint8_t         get8(pint_t addr) {
89    uint8_t val;
90    memcpy(&val, (void *)addr, sizeof(val));
91    return val;
92  }
93  uint16_t         get16(pint_t addr) {
94    uint16_t val;
95    memcpy(&val, (void *)addr, sizeof(val));
96    return val;
97  }
98  uint32_t         get32(pint_t addr) {
99    uint32_t val;
100    memcpy(&val, (void *)addr, sizeof(val));
101    return val;
102  }
103  uint64_t         get64(pint_t addr) {
104    uint64_t val;
105    memcpy(&val, (void *)addr, sizeof(val));
106    return val;
107  }
108  double           getDouble(pint_t addr) {
109    double val;
110    memcpy(&val, (void *)addr, sizeof(val));
111    return val;
112  }
113  v128             getVector(pint_t addr) {
114    v128 val;
115    memcpy(&val, (void *)addr, sizeof(val));
116    return val;
117  }
118  uintptr_t       getP(pint_t addr);
119  static uint64_t getULEB128(pint_t &addr, pint_t end);
120  static int64_t  getSLEB128(pint_t &addr, pint_t end);
121
122  pint_t getEncodedP(pint_t &addr, pint_t end, uint8_t encoding);
123  bool findFunctionName(pint_t addr, char *buf, size_t bufLen,
124                        unw_word_t *offset);
125  bool findUnwindSections(pint_t targetAddr, UnwindInfoSections &info);
126  bool findOtherFDE(pint_t targetAddr, pint_t &fde);
127
128  static LocalAddressSpace sThisAddressSpace;
129};
130
131inline uintptr_t LocalAddressSpace::getP(pint_t addr) {
132#if __LP64__
133  return get64(addr);
134#else
135  return get32(addr);
136#endif
137}
138
139/// Read a ULEB128 into a 64-bit word.
140inline uint64_t LocalAddressSpace::getULEB128(pint_t &addr, pint_t end) {
141  const uint8_t *p = (uint8_t *)addr;
142  const uint8_t *pend = (uint8_t *)end;
143  uint64_t result = 0;
144  int bit = 0;
145  do {
146    uint64_t b;
147
148    if (p == pend)
149      _LIBUNWIND_ABORT("truncated uleb128 expression");
150
151    b = *p & 0x7f;
152
153    if (bit >= 64 || b << bit >> bit != b) {
154      _LIBUNWIND_ABORT("malformed uleb128 expression");
155    } else {
156      result |= b << bit;
157      bit += 7;
158    }
159  } while (*p++ >= 0x80);
160  addr = (pint_t) p;
161  return result;
162}
163
164/// Read a SLEB128 into a 64-bit word.
165inline int64_t LocalAddressSpace::getSLEB128(pint_t &addr, pint_t end) {
166  const uint8_t *p = (uint8_t *)addr;
167  const uint8_t *pend = (uint8_t *)end;
168  int64_t result = 0;
169  int bit = 0;
170  uint8_t byte;
171  do {
172    if (p == pend)
173      _LIBUNWIND_ABORT("truncated sleb128 expression");
174    byte = *p++;
175    result |= ((byte & 0x7f) << bit);
176    bit += 7;
177  } while (byte & 0x80);
178  // sign extend negative numbers
179  if ((byte & 0x40) != 0)
180    result |= (-1LL) << bit;
181  addr = (pint_t) p;
182  return result;
183}
184
185inline LocalAddressSpace::pint_t LocalAddressSpace::getEncodedP(pint_t &addr,
186                                                         pint_t end,
187                                                         uint8_t encoding) {
188  pint_t startAddr = addr;
189  const uint8_t *p = (uint8_t *)addr;
190  pint_t result;
191
192  // first get value
193  switch (encoding & 0x0F) {
194  case DW_EH_PE_ptr:
195    result = getP(addr);
196    p += sizeof(pint_t);
197    addr = (pint_t) p;
198    break;
199  case DW_EH_PE_uleb128:
200    result = (pint_t)getULEB128(addr, end);
201    break;
202  case DW_EH_PE_udata2:
203    result = get16(addr);
204    p += 2;
205    addr = (pint_t) p;
206    break;
207  case DW_EH_PE_udata4:
208    result = get32(addr);
209    p += 4;
210    addr = (pint_t) p;
211    break;
212  case DW_EH_PE_udata8:
213    result = (pint_t)get64(addr);
214    p += 8;
215    addr = (pint_t) p;
216    break;
217  case DW_EH_PE_sleb128:
218    result = (pint_t)getSLEB128(addr, end);
219    break;
220  case DW_EH_PE_sdata2:
221    // Sign extend from signed 16-bit value.
222    result = (pint_t)(int16_t)get16(addr);
223    p += 2;
224    addr = (pint_t) p;
225    break;
226  case DW_EH_PE_sdata4:
227    // Sign extend from signed 32-bit value.
228    result = (pint_t)(int32_t)get32(addr);
229    p += 4;
230    addr = (pint_t) p;
231    break;
232  case DW_EH_PE_sdata8:
233    result = (pint_t)get64(addr);
234    p += 8;
235    addr = (pint_t) p;
236    break;
237  default:
238    _LIBUNWIND_ABORT("unknown pointer encoding");
239  }
240
241  // then add relative offset
242  switch (encoding & 0x70) {
243  case DW_EH_PE_absptr:
244    // do nothing
245    break;
246  case DW_EH_PE_pcrel:
247    result += startAddr;
248    break;
249  case DW_EH_PE_textrel:
250    _LIBUNWIND_ABORT("DW_EH_PE_textrel pointer encoding not supported");
251    break;
252  case DW_EH_PE_datarel:
253    _LIBUNWIND_ABORT("DW_EH_PE_datarel pointer encoding not supported");
254    break;
255  case DW_EH_PE_funcrel:
256    _LIBUNWIND_ABORT("DW_EH_PE_funcrel pointer encoding not supported");
257    break;
258  case DW_EH_PE_aligned:
259    _LIBUNWIND_ABORT("DW_EH_PE_aligned pointer encoding not supported");
260    break;
261  default:
262    _LIBUNWIND_ABORT("unknown pointer encoding");
263    break;
264  }
265
266  if (encoding & DW_EH_PE_indirect)
267    result = getP(result);
268
269  return result;
270}
271
272#if __APPLE__
273  struct dyld_unwind_sections
274  {
275    const struct mach_header*   mh;
276    const void*                 dwarf_section;
277    uintptr_t                   dwarf_section_length;
278    const void*                 compact_unwind_section;
279    uintptr_t                   compact_unwind_section_length;
280  };
281  #if (defined(__MAC_OS_X_VERSION_MIN_REQUIRED) \
282                                 && (__MAC_OS_X_VERSION_MIN_REQUIRED >= 1070)) \
283      || defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
284    // In 10.7.0 or later, libSystem.dylib implements this function.
285    extern "C" bool _dyld_find_unwind_sections(void *, dyld_unwind_sections *);
286  #else
287    // In 10.6.x and earlier, we need to implement this functionality.
288    static inline bool _dyld_find_unwind_sections(void* addr,
289                                                    dyld_unwind_sections* info) {
290      // Find mach-o image containing address.
291      Dl_info dlinfo;
292      if (!dladdr(addr, &dlinfo))
293        return false;
294      const mach_header *mh = (const mach_header *)dlinfo.dli_saddr;
295
296      // Find dwarf unwind section in that image.
297      unsigned long size;
298      const uint8_t *p = getsectiondata(mh, "__TEXT", "__eh_frame", &size);
299      if (!p)
300        return false;
301
302      // Fill in return struct.
303      info->mh = mh;
304      info->dwarf_section = p;
305      info->dwarf_section_length = size;
306      info->compact_unwind_section = 0;
307      info->compact_unwind_section_length = 0;
308
309      return true;
310    }
311  #endif
312#endif
313
314inline bool LocalAddressSpace::findUnwindSections(pint_t targetAddr,
315                                                  UnwindInfoSections &info) {
316#if __APPLE__
317  dyld_unwind_sections dyldInfo;
318  if (_dyld_find_unwind_sections((void *)targetAddr, &dyldInfo)) {
319    info.dso_base                      = (uintptr_t)dyldInfo.mh;
320 #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
321    info.dwarf_section                 = (uintptr_t)dyldInfo.dwarf_section;
322    info.dwarf_section_length          = dyldInfo.dwarf_section_length;
323 #endif
324    info.compact_unwind_section        = (uintptr_t)dyldInfo.compact_unwind_section;
325    info.compact_unwind_section_length = dyldInfo.compact_unwind_section_length;
326    return true;
327  }
328#elif LIBCXXABI_ARM_EHABI
329  int length = 0;
330  info.arm_section = (uintptr_t) dl_unwind_find_exidx(
331      (_Unwind_Ptr) targetAddr, &length);
332  info.arm_section_length = (uintptr_t)length;
333  _LIBUNWIND_TRACE_UNWINDING("findUnwindSections: section %X length %x\n",
334                             info.arm_section, info.arm_section_length);
335  if (info.arm_section && info.arm_section_length)
336    return true;
337#endif
338
339  return false;
340}
341
342
343inline bool LocalAddressSpace::findOtherFDE(pint_t targetAddr, pint_t &fde) {
344#if __APPLE__
345  return checkKeyMgrRegisteredFDEs(targetAddr, *((void**)&fde));
346#else
347  // TO DO: if OS has way to dynamically register FDEs, check that.
348  (void)targetAddr;
349  (void)fde;
350  return false;
351#endif
352}
353
354inline bool LocalAddressSpace::findFunctionName(pint_t addr, char *buf,
355                                                size_t bufLen,
356                                                unw_word_t *offset) {
357  Dl_info dyldInfo;
358  if (dladdr((void *)addr, &dyldInfo)) {
359    if (dyldInfo.dli_sname != NULL) {
360      snprintf(buf, bufLen, "%s", dyldInfo.dli_sname);
361      *offset = (addr - (pint_t) dyldInfo.dli_saddr);
362      return true;
363    }
364  }
365  return false;
366}
367
368
369
370#if UNW_REMOTE
371
372/// OtherAddressSpace is used as a template parameter to UnwindCursor when
373/// unwinding a thread in the another process.  The other process can be a
374/// different endianness and a different pointer size which is handled by
375/// the P template parameter.
376template <typename P>
377class OtherAddressSpace {
378public:
379  OtherAddressSpace(task_t task) : fTask(task) {}
380
381  typedef typename P::uint_t pint_t;
382
383  uint8_t   get8(pint_t addr);
384  uint16_t  get16(pint_t addr);
385  uint32_t  get32(pint_t addr);
386  uint64_t  get64(pint_t addr);
387  pint_t    getP(pint_t addr);
388  uint64_t  getULEB128(pint_t &addr, pint_t end);
389  int64_t   getSLEB128(pint_t &addr, pint_t end);
390  pint_t    getEncodedP(pint_t &addr, pint_t end, uint8_t encoding);
391  bool      findFunctionName(pint_t addr, char *buf, size_t bufLen,
392                        unw_word_t *offset);
393  bool      findUnwindSections(pint_t targetAddr, UnwindInfoSections &info);
394  bool      findOtherFDE(pint_t targetAddr, pint_t &fde);
395private:
396  void *localCopy(pint_t addr);
397
398  task_t fTask;
399};
400
401template <typename P> uint8_t OtherAddressSpace<P>::get8(pint_t addr) {
402  return *((uint8_t *)localCopy(addr));
403}
404
405template <typename P> uint16_t OtherAddressSpace<P>::get16(pint_t addr) {
406  return P::E::get16(*(uint16_t *)localCopy(addr));
407}
408
409template <typename P> uint32_t OtherAddressSpace<P>::get32(pint_t addr) {
410  return P::E::get32(*(uint32_t *)localCopy(addr));
411}
412
413template <typename P> uint64_t OtherAddressSpace<P>::get64(pint_t addr) {
414  return P::E::get64(*(uint64_t *)localCopy(addr));
415}
416
417template <typename P>
418typename P::uint_t OtherAddressSpace<P>::getP(pint_t addr) {
419  return P::getP(*(uint64_t *)localCopy(addr));
420}
421
422template <typename P>
423uint64_t OtherAddressSpace<P>::getULEB128(pint_t &addr, pint_t end) {
424  uintptr_t size = (end - addr);
425  LocalAddressSpace::pint_t laddr = (LocalAddressSpace::pint_t) localCopy(addr);
426  LocalAddressSpace::pint_t sladdr = laddr;
427  uint64_t result = LocalAddressSpace::getULEB128(laddr, laddr + size);
428  addr += (laddr - sladdr);
429  return result;
430}
431
432template <typename P>
433int64_t OtherAddressSpace<P>::getSLEB128(pint_t &addr, pint_t end) {
434  uintptr_t size = (end - addr);
435  LocalAddressSpace::pint_t laddr = (LocalAddressSpace::pint_t) localCopy(addr);
436  LocalAddressSpace::pint_t sladdr = laddr;
437  uint64_t result = LocalAddressSpace::getSLEB128(laddr, laddr + size);
438  addr += (laddr - sladdr);
439  return result;
440}
441
442template <typename P> void *OtherAddressSpace<P>::localCopy(pint_t addr) {
443  // FIX ME
444}
445
446template <typename P>
447bool OtherAddressSpace<P>::findFunctionName(pint_t addr, char *buf,
448                                            size_t bufLen, unw_word_t *offset) {
449  // FIX ME
450}
451
452/// unw_addr_space is the base class that abstract unw_addr_space_t type in
453/// libunwind.h points to.
454struct unw_addr_space {
455  cpu_type_t cpuType;
456  task_t taskPort;
457};
458
459/// unw_addr_space_i386 is the concrete instance that a unw_addr_space_t points
460/// to when examining
461/// a 32-bit intel process.
462struct unw_addr_space_i386 : public unw_addr_space {
463  unw_addr_space_i386(task_t task) : oas(task) {}
464  OtherAddressSpace<Pointer32<LittleEndian> > oas;
465};
466
467/// unw_addr_space_x86_64 is the concrete instance that a unw_addr_space_t
468/// points to when examining
469/// a 64-bit intel process.
470struct unw_addr_space_x86_64 : public unw_addr_space {
471  unw_addr_space_x86_64(task_t task) : oas(task) {}
472  OtherAddressSpace<Pointer64<LittleEndian> > oas;
473};
474
475/// unw_addr_space_ppc is the concrete instance that a unw_addr_space_t points
476/// to when examining
477/// a 32-bit PowerPC process.
478struct unw_addr_space_ppc : public unw_addr_space {
479  unw_addr_space_ppc(task_t task) : oas(task) {}
480  OtherAddressSpace<Pointer32<BigEndian> > oas;
481};
482
483#endif // UNW_REMOTE
484
485} // namespace libunwind
486
487#endif // __ADDRESSSPACE_HPP__
488