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>
24 namespace 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
37 typedef long unsigned int *_Unwind_Ptr;
38 extern "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
48 namespace libunwind {
49
50 /// Used by findUnwindSections() to return info about needed sections.
51 struct 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.
79 class __attribute__((visibility("hidden"))) LocalAddressSpace {
80 public:
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
get8(pint_t addr)88 uint8_t get8(pint_t addr) {
89 uint8_t val;
90 memcpy(&val, (void *)addr, sizeof(val));
91 return val;
92 }
get16(pint_t addr)93 uint16_t get16(pint_t addr) {
94 uint16_t val;
95 memcpy(&val, (void *)addr, sizeof(val));
96 return val;
97 }
get32(pint_t addr)98 uint32_t get32(pint_t addr) {
99 uint32_t val;
100 memcpy(&val, (void *)addr, sizeof(val));
101 return val;
102 }
get64(pint_t addr)103 uint64_t get64(pint_t addr) {
104 uint64_t val;
105 memcpy(&val, (void *)addr, sizeof(val));
106 return val;
107 }
getDouble(pint_t addr)108 double getDouble(pint_t addr) {
109 double val;
110 memcpy(&val, (void *)addr, sizeof(val));
111 return val;
112 }
getVector(pint_t addr)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
getP(pint_t addr)131 inline 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.
getULEB128(pint_t & addr,pint_t end)140 inline 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.
getSLEB128(pint_t & addr,pint_t end)165 inline 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
getEncodedP(pint_t & addr,pint_t end,uint8_t encoding)185 inline 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.
_dyld_find_unwind_sections(void * addr,dyld_unwind_sections * info)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
findUnwindSections(pint_t targetAddr,UnwindInfoSections & info)314 inline 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
findOtherFDE(pint_t targetAddr,pint_t & fde)343 inline 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
findFunctionName(pint_t addr,char * buf,size_t bufLen,unw_word_t * offset)354 inline 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.
376 template <typename P>
377 class OtherAddressSpace {
378 public:
OtherAddressSpace(task_t task)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);
395 private:
396 void *localCopy(pint_t addr);
397
398 task_t fTask;
399 };
400
get8(pint_t addr)401 template <typename P> uint8_t OtherAddressSpace<P>::get8(pint_t addr) {
402 return *((uint8_t *)localCopy(addr));
403 }
404
get16(pint_t addr)405 template <typename P> uint16_t OtherAddressSpace<P>::get16(pint_t addr) {
406 return P::E::get16(*(uint16_t *)localCopy(addr));
407 }
408
get32(pint_t addr)409 template <typename P> uint32_t OtherAddressSpace<P>::get32(pint_t addr) {
410 return P::E::get32(*(uint32_t *)localCopy(addr));
411 }
412
get64(pint_t addr)413 template <typename P> uint64_t OtherAddressSpace<P>::get64(pint_t addr) {
414 return P::E::get64(*(uint64_t *)localCopy(addr));
415 }
416
417 template <typename P>
getP(pint_t addr)418 typename P::uint_t OtherAddressSpace<P>::getP(pint_t addr) {
419 return P::getP(*(uint64_t *)localCopy(addr));
420 }
421
422 template <typename P>
getULEB128(pint_t & addr,pint_t end)423 uint64_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
432 template <typename P>
getSLEB128(pint_t & addr,pint_t end)433 int64_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
localCopy(pint_t addr)442 template <typename P> void *OtherAddressSpace<P>::localCopy(pint_t addr) {
443 // FIX ME
444 }
445
446 template <typename P>
findFunctionName(pint_t addr,char * buf,size_t bufLen,unw_word_t * offset)447 bool 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.
454 struct 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.
462 struct unw_addr_space_i386 : public unw_addr_space {
unw_addr_space_i386libunwind::unw_addr_space_i386463 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.
470 struct unw_addr_space_x86_64 : public unw_addr_space {
unw_addr_space_x86_64libunwind::unw_addr_space_x86_64471 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.
478 struct unw_addr_space_ppc : public unw_addr_space {
unw_addr_space_ppclibunwind::unw_addr_space_ppc479 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