1 //===------------------------- UnwindCursor.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 // C++ interface to lower levels of libuwind
10 //===----------------------------------------------------------------------===//
11
12 #ifndef __UNWINDCURSOR_HPP__
13 #define __UNWINDCURSOR_HPP__
14
15 #include <algorithm>
16 #include <stdint.h>
17 #include <stdio.h>
18 #include <stdlib.h>
19 #include <pthread.h>
20 #include <unwind.h>
21
22 #if __APPLE__
23 #include <mach-o/dyld.h>
24 #endif
25
26 #include "libunwind.h"
27
28 #include "AddressSpace.hpp"
29 #include "Registers.hpp"
30 #include "DwarfInstructions.hpp"
31 #include "CompactUnwinder.hpp"
32 #include "config.h"
33
34 namespace libunwind {
35
36 #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
37 /// Cache of recently found FDEs.
38 template <typename A>
39 class _LIBUNWIND_HIDDEN DwarfFDECache {
40 typedef typename A::pint_t pint_t;
41 public:
42 static pint_t findFDE(pint_t mh, pint_t pc);
43 static void add(pint_t mh, pint_t ip_start, pint_t ip_end, pint_t fde);
44 static void removeAllIn(pint_t mh);
45 static void iterateCacheEntries(void (*func)(unw_word_t ip_start,
46 unw_word_t ip_end,
47 unw_word_t fde, unw_word_t mh));
48
49 private:
50
51 struct entry {
52 pint_t mh;
53 pint_t ip_start;
54 pint_t ip_end;
55 pint_t fde;
56 };
57
58 // These fields are all static to avoid needing an initializer.
59 // There is only one instance of this class per process.
60 static pthread_rwlock_t _lock;
61 #if __APPLE__
62 static void dyldUnloadHook(const struct mach_header *mh, intptr_t slide);
63 static bool _registeredForDyldUnloads;
64 #endif
65 // Can't use std::vector<> here because this code is below libc++.
66 static entry *_buffer;
67 static entry *_bufferUsed;
68 static entry *_bufferEnd;
69 static entry _initialBuffer[64];
70 };
71
72 template <typename A>
73 typename DwarfFDECache<A>::entry *
74 DwarfFDECache<A>::_buffer = _initialBuffer;
75
76 template <typename A>
77 typename DwarfFDECache<A>::entry *
78 DwarfFDECache<A>::_bufferUsed = _initialBuffer;
79
80 template <typename A>
81 typename DwarfFDECache<A>::entry *
82 DwarfFDECache<A>::_bufferEnd = &_initialBuffer[64];
83
84 template <typename A>
85 typename DwarfFDECache<A>::entry DwarfFDECache<A>::_initialBuffer[64];
86
87 template <typename A>
88 pthread_rwlock_t DwarfFDECache<A>::_lock = PTHREAD_RWLOCK_INITIALIZER;
89
90 #if __APPLE__
91 template <typename A>
92 bool DwarfFDECache<A>::_registeredForDyldUnloads = false;
93 #endif
94
95 template <typename A>
findFDE(pint_t mh,pint_t pc)96 typename A::pint_t DwarfFDECache<A>::findFDE(pint_t mh, pint_t pc) {
97 pint_t result = 0;
98 _LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_rdlock(&_lock));
99 for (entry *p = _buffer; p < _bufferUsed; ++p) {
100 if ((mh == p->mh) || (mh == 0)) {
101 if ((p->ip_start <= pc) && (pc < p->ip_end)) {
102 result = p->fde;
103 break;
104 }
105 }
106 }
107 _LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_unlock(&_lock));
108 return result;
109 }
110
111 template <typename A>
add(pint_t mh,pint_t ip_start,pint_t ip_end,pint_t fde)112 void DwarfFDECache<A>::add(pint_t mh, pint_t ip_start, pint_t ip_end,
113 pint_t fde) {
114 _LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_wrlock(&_lock));
115 if (_bufferUsed >= _bufferEnd) {
116 size_t oldSize = (size_t)(_bufferEnd - _buffer);
117 size_t newSize = oldSize * 4;
118 // Can't use operator new (we are below it).
119 entry *newBuffer = (entry *)malloc(newSize * sizeof(entry));
120 memcpy(newBuffer, _buffer, oldSize * sizeof(entry));
121 if (_buffer != _initialBuffer)
122 free(_buffer);
123 _buffer = newBuffer;
124 _bufferUsed = &newBuffer[oldSize];
125 _bufferEnd = &newBuffer[newSize];
126 }
127 _bufferUsed->mh = mh;
128 _bufferUsed->ip_start = ip_start;
129 _bufferUsed->ip_end = ip_end;
130 _bufferUsed->fde = fde;
131 ++_bufferUsed;
132 #if __APPLE__
133 if (!_registeredForDyldUnloads) {
134 _dyld_register_func_for_remove_image(&dyldUnloadHook);
135 _registeredForDyldUnloads = true;
136 }
137 #endif
138 _LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_unlock(&_lock));
139 }
140
141 template <typename A>
removeAllIn(pint_t mh)142 void DwarfFDECache<A>::removeAllIn(pint_t mh) {
143 _LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_wrlock(&_lock));
144 entry *d = _buffer;
145 for (const entry *s = _buffer; s < _bufferUsed; ++s) {
146 if (s->mh != mh) {
147 if (d != s)
148 *d = *s;
149 ++d;
150 }
151 }
152 _bufferUsed = d;
153 _LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_unlock(&_lock));
154 }
155
156 #if __APPLE__
157 template <typename A>
dyldUnloadHook(const struct mach_header * mh,intptr_t)158 void DwarfFDECache<A>::dyldUnloadHook(const struct mach_header *mh, intptr_t ) {
159 removeAllIn((pint_t) mh);
160 }
161 #endif
162
163 template <typename A>
iterateCacheEntries(void (* func)(unw_word_t ip_start,unw_word_t ip_end,unw_word_t fde,unw_word_t mh))164 void DwarfFDECache<A>::iterateCacheEntries(void (*func)(
165 unw_word_t ip_start, unw_word_t ip_end, unw_word_t fde, unw_word_t mh)) {
166 _LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_wrlock(&_lock));
167 for (entry *p = _buffer; p < _bufferUsed; ++p) {
168 (*func)(p->ip_start, p->ip_end, p->fde, p->mh);
169 }
170 _LIBUNWIND_LOG_NON_ZERO(::pthread_rwlock_unlock(&_lock));
171 }
172 #endif // _LIBUNWIND_SUPPORT_DWARF_UNWIND
173
174
175 #define arrayoffsetof(type, index, field) ((size_t)(&((type *)0)[index].field))
176
177 #if _LIBUNWIND_SUPPORT_COMPACT_UNWIND
178 template <typename A> class UnwindSectionHeader {
179 public:
UnwindSectionHeader(A & addressSpace,typename A::pint_t addr)180 UnwindSectionHeader(A &addressSpace, typename A::pint_t addr)
181 : _addressSpace(addressSpace), _addr(addr) {}
182
version() const183 uint32_t version() const {
184 return _addressSpace.get32(_addr +
185 offsetof(unwind_info_section_header, version));
186 }
commonEncodingsArraySectionOffset() const187 uint32_t commonEncodingsArraySectionOffset() const {
188 return _addressSpace.get32(_addr +
189 offsetof(unwind_info_section_header,
190 commonEncodingsArraySectionOffset));
191 }
commonEncodingsArrayCount() const192 uint32_t commonEncodingsArrayCount() const {
193 return _addressSpace.get32(_addr + offsetof(unwind_info_section_header,
194 commonEncodingsArrayCount));
195 }
personalityArraySectionOffset() const196 uint32_t personalityArraySectionOffset() const {
197 return _addressSpace.get32(_addr + offsetof(unwind_info_section_header,
198 personalityArraySectionOffset));
199 }
personalityArrayCount() const200 uint32_t personalityArrayCount() const {
201 return _addressSpace.get32(
202 _addr + offsetof(unwind_info_section_header, personalityArrayCount));
203 }
indexSectionOffset() const204 uint32_t indexSectionOffset() const {
205 return _addressSpace.get32(
206 _addr + offsetof(unwind_info_section_header, indexSectionOffset));
207 }
indexCount() const208 uint32_t indexCount() const {
209 return _addressSpace.get32(
210 _addr + offsetof(unwind_info_section_header, indexCount));
211 }
212
213 private:
214 A &_addressSpace;
215 typename A::pint_t _addr;
216 };
217
218 template <typename A> class UnwindSectionIndexArray {
219 public:
UnwindSectionIndexArray(A & addressSpace,typename A::pint_t addr)220 UnwindSectionIndexArray(A &addressSpace, typename A::pint_t addr)
221 : _addressSpace(addressSpace), _addr(addr) {}
222
functionOffset(uint32_t index) const223 uint32_t functionOffset(uint32_t index) const {
224 return _addressSpace.get32(
225 _addr + arrayoffsetof(unwind_info_section_header_index_entry, index,
226 functionOffset));
227 }
secondLevelPagesSectionOffset(uint32_t index) const228 uint32_t secondLevelPagesSectionOffset(uint32_t index) const {
229 return _addressSpace.get32(
230 _addr + arrayoffsetof(unwind_info_section_header_index_entry, index,
231 secondLevelPagesSectionOffset));
232 }
lsdaIndexArraySectionOffset(uint32_t index) const233 uint32_t lsdaIndexArraySectionOffset(uint32_t index) const {
234 return _addressSpace.get32(
235 _addr + arrayoffsetof(unwind_info_section_header_index_entry, index,
236 lsdaIndexArraySectionOffset));
237 }
238
239 private:
240 A &_addressSpace;
241 typename A::pint_t _addr;
242 };
243
244 template <typename A> class UnwindSectionRegularPageHeader {
245 public:
UnwindSectionRegularPageHeader(A & addressSpace,typename A::pint_t addr)246 UnwindSectionRegularPageHeader(A &addressSpace, typename A::pint_t addr)
247 : _addressSpace(addressSpace), _addr(addr) {}
248
kind() const249 uint32_t kind() const {
250 return _addressSpace.get32(
251 _addr + offsetof(unwind_info_regular_second_level_page_header, kind));
252 }
entryPageOffset() const253 uint16_t entryPageOffset() const {
254 return _addressSpace.get16(
255 _addr + offsetof(unwind_info_regular_second_level_page_header,
256 entryPageOffset));
257 }
entryCount() const258 uint16_t entryCount() const {
259 return _addressSpace.get16(
260 _addr +
261 offsetof(unwind_info_regular_second_level_page_header, entryCount));
262 }
263
264 private:
265 A &_addressSpace;
266 typename A::pint_t _addr;
267 };
268
269 template <typename A> class UnwindSectionRegularArray {
270 public:
UnwindSectionRegularArray(A & addressSpace,typename A::pint_t addr)271 UnwindSectionRegularArray(A &addressSpace, typename A::pint_t addr)
272 : _addressSpace(addressSpace), _addr(addr) {}
273
functionOffset(uint32_t index) const274 uint32_t functionOffset(uint32_t index) const {
275 return _addressSpace.get32(
276 _addr + arrayoffsetof(unwind_info_regular_second_level_entry, index,
277 functionOffset));
278 }
encoding(uint32_t index) const279 uint32_t encoding(uint32_t index) const {
280 return _addressSpace.get32(
281 _addr +
282 arrayoffsetof(unwind_info_regular_second_level_entry, index, encoding));
283 }
284
285 private:
286 A &_addressSpace;
287 typename A::pint_t _addr;
288 };
289
290 template <typename A> class UnwindSectionCompressedPageHeader {
291 public:
UnwindSectionCompressedPageHeader(A & addressSpace,typename A::pint_t addr)292 UnwindSectionCompressedPageHeader(A &addressSpace, typename A::pint_t addr)
293 : _addressSpace(addressSpace), _addr(addr) {}
294
kind() const295 uint32_t kind() const {
296 return _addressSpace.get32(
297 _addr +
298 offsetof(unwind_info_compressed_second_level_page_header, kind));
299 }
entryPageOffset() const300 uint16_t entryPageOffset() const {
301 return _addressSpace.get16(
302 _addr + offsetof(unwind_info_compressed_second_level_page_header,
303 entryPageOffset));
304 }
entryCount() const305 uint16_t entryCount() const {
306 return _addressSpace.get16(
307 _addr +
308 offsetof(unwind_info_compressed_second_level_page_header, entryCount));
309 }
encodingsPageOffset() const310 uint16_t encodingsPageOffset() const {
311 return _addressSpace.get16(
312 _addr + offsetof(unwind_info_compressed_second_level_page_header,
313 encodingsPageOffset));
314 }
encodingsCount() const315 uint16_t encodingsCount() const {
316 return _addressSpace.get16(
317 _addr + offsetof(unwind_info_compressed_second_level_page_header,
318 encodingsCount));
319 }
320
321 private:
322 A &_addressSpace;
323 typename A::pint_t _addr;
324 };
325
326 template <typename A> class UnwindSectionCompressedArray {
327 public:
UnwindSectionCompressedArray(A & addressSpace,typename A::pint_t addr)328 UnwindSectionCompressedArray(A &addressSpace, typename A::pint_t addr)
329 : _addressSpace(addressSpace), _addr(addr) {}
330
functionOffset(uint32_t index) const331 uint32_t functionOffset(uint32_t index) const {
332 return UNWIND_INFO_COMPRESSED_ENTRY_FUNC_OFFSET(
333 _addressSpace.get32(_addr + index * sizeof(uint32_t)));
334 }
encodingIndex(uint32_t index) const335 uint16_t encodingIndex(uint32_t index) const {
336 return UNWIND_INFO_COMPRESSED_ENTRY_ENCODING_INDEX(
337 _addressSpace.get32(_addr + index * sizeof(uint32_t)));
338 }
339
340 private:
341 A &_addressSpace;
342 typename A::pint_t _addr;
343 };
344
345 template <typename A> class UnwindSectionLsdaArray {
346 public:
UnwindSectionLsdaArray(A & addressSpace,typename A::pint_t addr)347 UnwindSectionLsdaArray(A &addressSpace, typename A::pint_t addr)
348 : _addressSpace(addressSpace), _addr(addr) {}
349
functionOffset(uint32_t index) const350 uint32_t functionOffset(uint32_t index) const {
351 return _addressSpace.get32(
352 _addr + arrayoffsetof(unwind_info_section_header_lsda_index_entry,
353 index, functionOffset));
354 }
lsdaOffset(uint32_t index) const355 uint32_t lsdaOffset(uint32_t index) const {
356 return _addressSpace.get32(
357 _addr + arrayoffsetof(unwind_info_section_header_lsda_index_entry,
358 index, lsdaOffset));
359 }
360
361 private:
362 A &_addressSpace;
363 typename A::pint_t _addr;
364 };
365 #endif // _LIBUNWIND_SUPPORT_COMPACT_UNWIND
366
367
368 class _LIBUNWIND_HIDDEN AbstractUnwindCursor {
369 public:
~AbstractUnwindCursor()370 virtual ~AbstractUnwindCursor() {}
371 virtual bool validReg(int) = 0;
372 virtual unw_word_t getReg(int) = 0;
373 virtual void setReg(int, unw_word_t) = 0;
374 virtual bool validFloatReg(int) = 0;
375 virtual unw_fpreg_t getFloatReg(int) = 0;
376 virtual void setFloatReg(int, unw_fpreg_t) = 0;
377 virtual int step() = 0;
378 virtual void getInfo(unw_proc_info_t *) = 0;
379 virtual void jumpto() = 0;
380 virtual bool isSignalFrame() = 0;
381 virtual bool getFunctionName(char *bf, size_t ln, unw_word_t *off) = 0;
382 virtual void setInfoBasedOnIPRegister(bool isReturnAddr = false) = 0;
383 virtual const char *getRegisterName(int num) = 0;
384 #if __arm__
385 virtual void saveVFPAsX() = 0;
386 #endif
387 };
388
389
390 /// UnwindCursor contains all state (including all register values) during
391 /// an unwind. This is normally stack allocated inside a unw_cursor_t.
392 template <typename A, typename R>
393 class UnwindCursor : public AbstractUnwindCursor{
394 typedef typename A::pint_t pint_t;
395 public:
396 UnwindCursor(unw_context_t *context, A &as);
397 UnwindCursor(A &as, void *threadArg);
~UnwindCursor()398 virtual ~UnwindCursor() {}
399 virtual bool validReg(int);
400 virtual unw_word_t getReg(int);
401 virtual void setReg(int, unw_word_t);
402 virtual bool validFloatReg(int);
403 virtual unw_fpreg_t getFloatReg(int);
404 virtual void setFloatReg(int, unw_fpreg_t);
405 virtual int step();
406 virtual void getInfo(unw_proc_info_t *);
407 virtual void jumpto();
408 virtual bool isSignalFrame();
409 virtual bool getFunctionName(char *buf, size_t len, unw_word_t *off);
410 virtual void setInfoBasedOnIPRegister(bool isReturnAddress = false);
411 virtual const char *getRegisterName(int num);
412 #if __arm__
413 virtual void saveVFPAsX();
414 #endif
415
operator delete(void *,size_t)416 void operator delete(void *, size_t) {}
417
418 private:
419
420 #if LIBCXXABI_ARM_EHABI
421 bool getInfoFromEHABISection(pint_t pc, const UnwindInfoSections §s);
422 #endif
423
424 #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
425 bool getInfoFromDwarfSection(pint_t pc, const UnwindInfoSections §s,
426 uint32_t fdeSectionOffsetHint=0);
stepWithDwarfFDE()427 int stepWithDwarfFDE() {
428 return DwarfInstructions<A, R>::stepWithDwarf(_addressSpace,
429 (pint_t)this->getReg(UNW_REG_IP),
430 (pint_t)_info.unwind_info,
431 _registers);
432 }
433 #endif
434
435 #if _LIBUNWIND_SUPPORT_COMPACT_UNWIND
436 bool getInfoFromCompactEncodingSection(pint_t pc,
437 const UnwindInfoSections §s);
stepWithCompactEncoding()438 int stepWithCompactEncoding() {
439 #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
440 if ( compactSaysUseDwarf() )
441 return stepWithDwarfFDE();
442 #endif
443 R dummy;
444 return stepWithCompactEncoding(dummy);
445 }
446
stepWithCompactEncoding(Registers_x86_64 &)447 int stepWithCompactEncoding(Registers_x86_64 &) {
448 return CompactUnwinder_x86_64<A>::stepWithCompactEncoding(
449 _info.format, _info.start_ip, _addressSpace, _registers);
450 }
451
stepWithCompactEncoding(Registers_x86 &)452 int stepWithCompactEncoding(Registers_x86 &) {
453 return CompactUnwinder_x86<A>::stepWithCompactEncoding(
454 _info.format, (uint32_t)_info.start_ip, _addressSpace, _registers);
455 }
456
stepWithCompactEncoding(Registers_ppc &)457 int stepWithCompactEncoding(Registers_ppc &) {
458 return UNW_EINVAL;
459 }
460
stepWithCompactEncoding(Registers_arm64 &)461 int stepWithCompactEncoding(Registers_arm64 &) {
462 return CompactUnwinder_arm64<A>::stepWithCompactEncoding(
463 _info.format, _info.start_ip, _addressSpace, _registers);
464 }
465
compactSaysUseDwarf(uint32_t * offset=NULL) const466 bool compactSaysUseDwarf(uint32_t *offset=NULL) const {
467 R dummy;
468 return compactSaysUseDwarf(dummy, offset);
469 }
470
compactSaysUseDwarf(Registers_x86_64 &,uint32_t * offset) const471 bool compactSaysUseDwarf(Registers_x86_64 &, uint32_t *offset) const {
472 if ((_info.format & UNWIND_X86_64_MODE_MASK) == UNWIND_X86_64_MODE_DWARF) {
473 if (offset)
474 *offset = (_info.format & UNWIND_X86_64_DWARF_SECTION_OFFSET);
475 return true;
476 }
477 return false;
478 }
479
compactSaysUseDwarf(Registers_x86 &,uint32_t * offset) const480 bool compactSaysUseDwarf(Registers_x86 &, uint32_t *offset) const {
481 if ((_info.format & UNWIND_X86_MODE_MASK) == UNWIND_X86_MODE_DWARF) {
482 if (offset)
483 *offset = (_info.format & UNWIND_X86_DWARF_SECTION_OFFSET);
484 return true;
485 }
486 return false;
487 }
488
compactSaysUseDwarf(Registers_ppc &,uint32_t *) const489 bool compactSaysUseDwarf(Registers_ppc &, uint32_t *) const {
490 return true;
491 }
492
compactSaysUseDwarf(Registers_arm64 &,uint32_t * offset) const493 bool compactSaysUseDwarf(Registers_arm64 &, uint32_t *offset) const {
494 if ((_info.format & UNWIND_ARM64_MODE_MASK) == UNWIND_ARM64_MODE_DWARF) {
495 if (offset)
496 *offset = (_info.format & UNWIND_ARM64_DWARF_SECTION_OFFSET);
497 return true;
498 }
499 return false;
500 }
501 #endif // _LIBUNWIND_SUPPORT_COMPACT_UNWIND
502
503 #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
dwarfEncoding() const504 compact_unwind_encoding_t dwarfEncoding() const {
505 R dummy;
506 return dwarfEncoding(dummy);
507 }
508
dwarfEncoding(Registers_x86_64 &) const509 compact_unwind_encoding_t dwarfEncoding(Registers_x86_64 &) const {
510 return UNWIND_X86_64_MODE_DWARF;
511 }
512
dwarfEncoding(Registers_x86 &) const513 compact_unwind_encoding_t dwarfEncoding(Registers_x86 &) const {
514 return UNWIND_X86_MODE_DWARF;
515 }
516
dwarfEncoding(Registers_ppc &) const517 compact_unwind_encoding_t dwarfEncoding(Registers_ppc &) const {
518 return 0;
519 }
520
dwarfEncoding(Registers_arm64 &) const521 compact_unwind_encoding_t dwarfEncoding(Registers_arm64 &) const {
522 return UNWIND_ARM64_MODE_DWARF;
523 }
524 #endif // _LIBUNWIND_SUPPORT_DWARF_UNWIND
525
526
527 A &_addressSpace;
528 R _registers;
529 unw_proc_info_t _info;
530 bool _unwindInfoMissing;
531 bool _isSignalFrame;
532 };
533
534
535 template <typename A, typename R>
UnwindCursor(unw_context_t * context,A & as)536 UnwindCursor<A, R>::UnwindCursor(unw_context_t *context, A &as)
537 : _addressSpace(as), _registers(context), _unwindInfoMissing(false),
538 _isSignalFrame(false) {
539 static_assert(sizeof(UnwindCursor<A, R>) < sizeof(unw_cursor_t),
540 "UnwindCursor<> does not fit in unw_cursor_t");
541 memset(&_info, 0, sizeof(_info));
542 }
543
544 template <typename A, typename R>
UnwindCursor(A & as,void *)545 UnwindCursor<A, R>::UnwindCursor(A &as, void *)
546 : _addressSpace(as), _unwindInfoMissing(false), _isSignalFrame(false) {
547 memset(&_info, 0, sizeof(_info));
548 // FIXME
549 // fill in _registers from thread arg
550 }
551
552
553 template <typename A, typename R>
validReg(int regNum)554 bool UnwindCursor<A, R>::validReg(int regNum) {
555 return _registers.validRegister(regNum);
556 }
557
558 template <typename A, typename R>
getReg(int regNum)559 unw_word_t UnwindCursor<A, R>::getReg(int regNum) {
560 return _registers.getRegister(regNum);
561 }
562
563 template <typename A, typename R>
setReg(int regNum,unw_word_t value)564 void UnwindCursor<A, R>::setReg(int regNum, unw_word_t value) {
565 _registers.setRegister(regNum, (typename A::pint_t)value);
566 }
567
568 template <typename A, typename R>
validFloatReg(int regNum)569 bool UnwindCursor<A, R>::validFloatReg(int regNum) {
570 return _registers.validFloatRegister(regNum);
571 }
572
573 template <typename A, typename R>
getFloatReg(int regNum)574 unw_fpreg_t UnwindCursor<A, R>::getFloatReg(int regNum) {
575 return _registers.getFloatRegister(regNum);
576 }
577
578 template <typename A, typename R>
setFloatReg(int regNum,unw_fpreg_t value)579 void UnwindCursor<A, R>::setFloatReg(int regNum, unw_fpreg_t value) {
580 _registers.setFloatRegister(regNum, value);
581 }
582
jumpto()583 template <typename A, typename R> void UnwindCursor<A, R>::jumpto() {
584 _registers.jumpto();
585 }
586
587 #if __arm__
saveVFPAsX()588 template <typename A, typename R> void UnwindCursor<A, R>::saveVFPAsX() {
589 _registers.saveVFPAsX();
590 }
591 #endif
592
593 template <typename A, typename R>
getRegisterName(int regNum)594 const char *UnwindCursor<A, R>::getRegisterName(int regNum) {
595 return _registers.getRegisterName(regNum);
596 }
597
isSignalFrame()598 template <typename A, typename R> bool UnwindCursor<A, R>::isSignalFrame() {
599 return _isSignalFrame;
600 }
601
602 #if LIBCXXABI_ARM_EHABI
603 struct EHABIIndexEntry {
604 uint32_t functionOffset;
605 uint32_t data;
606 };
607
608 // Unable to unwind in the ARM index table (section 5 EHABI).
609 #define UNW_EXIDX_CANTUNWIND 0x1
610
signExtendPrel31(uint32_t data)611 static inline uint32_t signExtendPrel31(uint32_t data) {
612 return data | ((data & 0x40000000u) << 1);
613 }
614
615 extern "C" _Unwind_Reason_Code __aeabi_unwind_cpp_pr0(
616 _Unwind_State state, _Unwind_Control_Block *ucbp, _Unwind_Context *context);
617 extern "C" _Unwind_Reason_Code __aeabi_unwind_cpp_pr1(
618 _Unwind_State state, _Unwind_Control_Block *ucbp, _Unwind_Context *context);
619 extern "C" _Unwind_Reason_Code __aeabi_unwind_cpp_pr2(
620 _Unwind_State state, _Unwind_Control_Block *ucbp, _Unwind_Context *context);
621
622 template<typename A>
623 struct EHABISectionIterator {
624 typedef EHABISectionIterator _Self;
625
626 typedef std::random_access_iterator_tag iterator_category;
627 typedef typename A::pint_t value_type;
628 typedef typename A::pint_t* pointer;
629 typedef typename A::pint_t& reference;
630 typedef size_t size_type;
631 typedef size_t difference_type;
632
beginlibunwind::EHABISectionIterator633 static _Self begin(A& addressSpace, const UnwindInfoSections& sects) {
634 return _Self(addressSpace, sects, 0);
635 }
endlibunwind::EHABISectionIterator636 static _Self end(A& addressSpace, const UnwindInfoSections& sects) {
637 return _Self(addressSpace, sects, sects.arm_section_length);
638 }
639
EHABISectionIteratorlibunwind::EHABISectionIterator640 EHABISectionIterator(A& addressSpace, const UnwindInfoSections& sects, size_t i)
641 : _addressSpace(&addressSpace), _sects(§s), _i(i) {}
642
operator ++libunwind::EHABISectionIterator643 _Self& operator++() { ++_i; return *this; }
operator +=libunwind::EHABISectionIterator644 _Self& operator+=(size_t a) { _i += a; return *this; }
operator --libunwind::EHABISectionIterator645 _Self& operator--() { assert(_i > 0); --_i; return *this; }
operator -=libunwind::EHABISectionIterator646 _Self& operator-=(size_t a) { assert(_i >= a); _i -= a; return *this; }
647
operator +libunwind::EHABISectionIterator648 _Self operator+(size_t a) { _Self out = *this; out._i += a; return out; }
operator -libunwind::EHABISectionIterator649 _Self operator-(size_t a) { assert(_i >= a); _Self out = *this; out._i -= a; return out; }
650
operator -libunwind::EHABISectionIterator651 size_t operator-(const _Self& other) { return _i - other._i; }
652
operator ==libunwind::EHABISectionIterator653 bool operator==(const _Self& other) const {
654 assert(_addressSpace == other._addressSpace);
655 assert(_sects == other._sects);
656 return _i == other._i;
657 }
658
operator *libunwind::EHABISectionIterator659 typename A::pint_t operator*() const { return functionAddress(); }
660
functionAddresslibunwind::EHABISectionIterator661 typename A::pint_t functionAddress() const {
662 typename A::pint_t indexAddr = _sects->arm_section + arrayoffsetof(
663 EHABIIndexEntry, _i, functionOffset);
664 return indexAddr + signExtendPrel31(_addressSpace->get32(indexAddr));
665 }
666
dataAddresslibunwind::EHABISectionIterator667 typename A::pint_t dataAddress() {
668 typename A::pint_t indexAddr = _sects->arm_section + arrayoffsetof(
669 EHABIIndexEntry, _i, data);
670 return indexAddr;
671 }
672
673 private:
674 size_t _i;
675 A* _addressSpace;
676 const UnwindInfoSections* _sects;
677 };
678
679 template <typename A, typename R>
getInfoFromEHABISection(pint_t pc,const UnwindInfoSections & sects)680 bool UnwindCursor<A, R>::getInfoFromEHABISection(
681 pint_t pc,
682 const UnwindInfoSections §s) {
683 EHABISectionIterator<A> begin =
684 EHABISectionIterator<A>::begin(_addressSpace, sects);
685 EHABISectionIterator<A> end =
686 EHABISectionIterator<A>::end(_addressSpace, sects);
687
688 EHABISectionIterator<A> itNextPC = std::upper_bound(begin, end, pc);
689 if (itNextPC == begin || itNextPC == end)
690 return false;
691 EHABISectionIterator<A> itThisPC = itNextPC - 1;
692
693 pint_t thisPC = itThisPC.functionAddress();
694 pint_t nextPC = itNextPC.functionAddress();
695 pint_t indexDataAddr = itThisPC.dataAddress();
696
697 if (indexDataAddr == 0)
698 return false;
699
700 uint32_t indexData = _addressSpace.get32(indexDataAddr);
701 if (indexData == UNW_EXIDX_CANTUNWIND)
702 return false;
703
704 // If the high bit is set, the exception handling table entry is inline inside
705 // the index table entry on the second word (aka |indexDataAddr|). Otherwise,
706 // the table points at an offset in the exception handling table (section 5 EHABI).
707 pint_t exceptionTableAddr;
708 uint32_t exceptionTableData;
709 bool isSingleWordEHT;
710 if (indexData & 0x80000000) {
711 exceptionTableAddr = indexDataAddr;
712 // TODO(ajwong): Should this data be 0?
713 exceptionTableData = indexData;
714 isSingleWordEHT = true;
715 } else {
716 exceptionTableAddr = indexDataAddr + signExtendPrel31(indexData);
717 exceptionTableData = _addressSpace.get32(exceptionTableAddr);
718 isSingleWordEHT = false;
719 }
720
721 // Now we know the 3 things:
722 // exceptionTableAddr -- exception handler table entry.
723 // exceptionTableData -- the data inside the first word of the eht entry.
724 // isSingleWordEHT -- whether the entry is in the index.
725 unw_word_t personalityRoutine = 0xbadf00d;
726 bool scope32 = false;
727 uintptr_t lsda = 0xbadf00d;
728
729 // If the high bit in the exception handling table entry is set, the entry is
730 // in compact form (section 6.3 EHABI).
731 if (exceptionTableData & 0x80000000) {
732 // Grab the index of the personality routine from the compact form.
733 int choice = (exceptionTableData & 0x0f000000) >> 24;
734 int extraWords = 0;
735 switch (choice) {
736 case 0:
737 personalityRoutine = (unw_word_t) &__aeabi_unwind_cpp_pr0;
738 extraWords = 0;
739 scope32 = false;
740 break;
741 case 1:
742 personalityRoutine = (unw_word_t) &__aeabi_unwind_cpp_pr1;
743 extraWords = (exceptionTableData & 0x00ff0000) >> 16;
744 scope32 = false;
745 break;
746 case 2:
747 personalityRoutine = (unw_word_t) &__aeabi_unwind_cpp_pr2;
748 extraWords = (exceptionTableData & 0x00ff0000) >> 16;
749 scope32 = true;
750 break;
751 default:
752 _LIBUNWIND_ABORT("unknown personality routine");
753 return false;
754 }
755
756 if (isSingleWordEHT) {
757 if (extraWords != 0) {
758 _LIBUNWIND_ABORT("index inlined table detected but pr function "
759 "requires extra words");
760 return false;
761 }
762 }
763 } else {
764 pint_t personalityAddr =
765 exceptionTableAddr + signExtendPrel31(exceptionTableData);
766 personalityRoutine = personalityAddr;
767
768 // ARM EHABI # 6.2, # 9.2
769 //
770 // +---- ehtp
771 // v
772 // +--------------------------------------+
773 // | +--------+--------+--------+-------+ |
774 // | |0| prel31 to personalityRoutine | |
775 // | +--------+--------+--------+-------+ |
776 // | | N | unwind opcodes | | <-- UnwindData
777 // | +--------+--------+--------+-------+ |
778 // | | Word 2 unwind opcodes | |
779 // | +--------+--------+--------+-------+ |
780 // | ... |
781 // | +--------+--------+--------+-------+ |
782 // | | Word N unwind opcodes | |
783 // | +--------+--------+--------+-------+ |
784 // | | LSDA | | <-- lsda
785 // | | ... | |
786 // | +--------+--------+--------+-------+ |
787 // +--------------------------------------+
788
789 uint32_t *UnwindData = reinterpret_cast<uint32_t*>(exceptionTableAddr) + 1;
790 uint32_t FirstDataWord = *UnwindData;
791 size_t N = ((FirstDataWord >> 24) & 0xff);
792 size_t NDataWords = N + 1;
793 lsda = reinterpret_cast<uintptr_t>(UnwindData + NDataWords);
794 }
795
796 _info.start_ip = thisPC;
797 _info.end_ip = nextPC;
798 _info.handler = personalityRoutine;
799 _info.unwind_info = exceptionTableAddr;
800 _info.lsda = lsda;
801 // flags is pr_cache.additional. See EHABI #7.2 for definition of bit 0.
802 _info.flags = isSingleWordEHT ? 1 : 0 | scope32 ? 0x2 : 0; // Use enum?
803
804 return true;
805 }
806 #endif
807
808 #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
809 template <typename A, typename R>
getInfoFromDwarfSection(pint_t pc,const UnwindInfoSections & sects,uint32_t fdeSectionOffsetHint)810 bool UnwindCursor<A, R>::getInfoFromDwarfSection(pint_t pc,
811 const UnwindInfoSections §s,
812 uint32_t fdeSectionOffsetHint) {
813 typename CFI_Parser<A>::FDE_Info fdeInfo;
814 typename CFI_Parser<A>::CIE_Info cieInfo;
815 bool foundFDE = false;
816 bool foundInCache = false;
817 // If compact encoding table gave offset into dwarf section, go directly there
818 if (fdeSectionOffsetHint != 0) {
819 foundFDE = CFI_Parser<A>::findFDE(_addressSpace, pc, sects.dwarf_section,
820 (uint32_t)sects.dwarf_section_length,
821 sects.dwarf_section + fdeSectionOffsetHint,
822 &fdeInfo, &cieInfo);
823 }
824 #if _LIBUNWIND_SUPPORT_DWARF_INDEX
825 if (!foundFDE && (sects.dwarf_index_section != 0)) {
826 // Have eh_frame_hdr section which is index into dwarf section.
827 // TO DO: implement index search
828 }
829 #endif
830 if (!foundFDE) {
831 // otherwise, search cache of previously found FDEs.
832 pint_t cachedFDE = DwarfFDECache<A>::findFDE(sects.dso_base, pc);
833 if (cachedFDE != 0) {
834 foundFDE =
835 CFI_Parser<A>::findFDE(_addressSpace, pc, sects.dwarf_section,
836 (uint32_t)sects.dwarf_section_length,
837 cachedFDE, &fdeInfo, &cieInfo);
838 foundInCache = foundFDE;
839 }
840 }
841 if (!foundFDE) {
842 // Still not found, do full scan of __eh_frame section.
843 foundFDE = CFI_Parser<A>::findFDE(_addressSpace, pc, sects.dwarf_section,
844 (uint32_t)sects.dwarf_section_length, 0,
845 &fdeInfo, &cieInfo);
846 }
847 if (foundFDE) {
848 typename CFI_Parser<A>::PrologInfo prolog;
849 if (CFI_Parser<A>::parseFDEInstructions(_addressSpace, fdeInfo, cieInfo, pc,
850 &prolog)) {
851 // Save off parsed FDE info
852 _info.start_ip = fdeInfo.pcStart;
853 _info.end_ip = fdeInfo.pcEnd;
854 _info.lsda = fdeInfo.lsda;
855 _info.handler = cieInfo.personality;
856 _info.gp = prolog.spExtraArgSize;
857 _info.flags = 0;
858 _info.format = dwarfEncoding();
859 _info.unwind_info = fdeInfo.fdeStart;
860 _info.unwind_info_size = (uint32_t)fdeInfo.fdeLength;
861 _info.extra = (unw_word_t) sects.dso_base;
862
863 // Add to cache (to make next lookup faster) if we had no hint
864 // and there was no index.
865 if (!foundInCache && (fdeSectionOffsetHint == 0)) {
866 #if _LIBUNWIND_SUPPORT_DWARF_INDEX
867 if (sects.dwarf_index_section == 0)
868 #endif
869 DwarfFDECache<A>::add(sects.dso_base, fdeInfo.pcStart, fdeInfo.pcEnd,
870 fdeInfo.fdeStart);
871 }
872 return true;
873 }
874 }
875 //_LIBUNWIND_DEBUG_LOG("can't find/use FDE for pc=0x%llX\n", (uint64_t)pc);
876 return false;
877 }
878 #endif // _LIBUNWIND_SUPPORT_DWARF_UNWIND
879
880
881 #if _LIBUNWIND_SUPPORT_COMPACT_UNWIND
882 template <typename A, typename R>
getInfoFromCompactEncodingSection(pint_t pc,const UnwindInfoSections & sects)883 bool UnwindCursor<A, R>::getInfoFromCompactEncodingSection(pint_t pc,
884 const UnwindInfoSections §s) {
885 const bool log = false;
886 if (log)
887 fprintf(stderr, "getInfoFromCompactEncodingSection(pc=0x%llX, mh=0x%llX)\n",
888 (uint64_t)pc, (uint64_t)sects.dso_base);
889
890 const UnwindSectionHeader<A> sectionHeader(_addressSpace,
891 sects.compact_unwind_section);
892 if (sectionHeader.version() != UNWIND_SECTION_VERSION)
893 return false;
894
895 // do a binary search of top level index to find page with unwind info
896 pint_t targetFunctionOffset = pc - sects.dso_base;
897 const UnwindSectionIndexArray<A> topIndex(_addressSpace,
898 sects.compact_unwind_section
899 + sectionHeader.indexSectionOffset());
900 uint32_t low = 0;
901 uint32_t high = sectionHeader.indexCount();
902 uint32_t last = high - 1;
903 while (low < high) {
904 uint32_t mid = (low + high) / 2;
905 //if ( log ) fprintf(stderr, "\tmid=%d, low=%d, high=%d, *mid=0x%08X\n",
906 //mid, low, high, topIndex.functionOffset(mid));
907 if (topIndex.functionOffset(mid) <= targetFunctionOffset) {
908 if ((mid == last) ||
909 (topIndex.functionOffset(mid + 1) > targetFunctionOffset)) {
910 low = mid;
911 break;
912 } else {
913 low = mid + 1;
914 }
915 } else {
916 high = mid;
917 }
918 }
919 const uint32_t firstLevelFunctionOffset = topIndex.functionOffset(low);
920 const uint32_t firstLevelNextPageFunctionOffset =
921 topIndex.functionOffset(low + 1);
922 const pint_t secondLevelAddr =
923 sects.compact_unwind_section + topIndex.secondLevelPagesSectionOffset(low);
924 const pint_t lsdaArrayStartAddr =
925 sects.compact_unwind_section + topIndex.lsdaIndexArraySectionOffset(low);
926 const pint_t lsdaArrayEndAddr =
927 sects.compact_unwind_section + topIndex.lsdaIndexArraySectionOffset(low+1);
928 if (log)
929 fprintf(stderr, "\tfirst level search for result index=%d "
930 "to secondLevelAddr=0x%llX\n",
931 low, (uint64_t) secondLevelAddr);
932 // do a binary search of second level page index
933 uint32_t encoding = 0;
934 pint_t funcStart = 0;
935 pint_t funcEnd = 0;
936 pint_t lsda = 0;
937 pint_t personality = 0;
938 uint32_t pageKind = _addressSpace.get32(secondLevelAddr);
939 if (pageKind == UNWIND_SECOND_LEVEL_REGULAR) {
940 // regular page
941 UnwindSectionRegularPageHeader<A> pageHeader(_addressSpace,
942 secondLevelAddr);
943 UnwindSectionRegularArray<A> pageIndex(
944 _addressSpace, secondLevelAddr + pageHeader.entryPageOffset());
945 // binary search looks for entry with e where index[e].offset <= pc <
946 // index[e+1].offset
947 if (log)
948 fprintf(stderr, "\tbinary search for targetFunctionOffset=0x%08llX in "
949 "regular page starting at secondLevelAddr=0x%llX\n",
950 (uint64_t) targetFunctionOffset, (uint64_t) secondLevelAddr);
951 low = 0;
952 high = pageHeader.entryCount();
953 while (low < high) {
954 uint32_t mid = (low + high) / 2;
955 if (pageIndex.functionOffset(mid) <= targetFunctionOffset) {
956 if (mid == (uint32_t)(pageHeader.entryCount() - 1)) {
957 // at end of table
958 low = mid;
959 funcEnd = firstLevelNextPageFunctionOffset + sects.dso_base;
960 break;
961 } else if (pageIndex.functionOffset(mid + 1) > targetFunctionOffset) {
962 // next is too big, so we found it
963 low = mid;
964 funcEnd = pageIndex.functionOffset(low + 1) + sects.dso_base;
965 break;
966 } else {
967 low = mid + 1;
968 }
969 } else {
970 high = mid;
971 }
972 }
973 encoding = pageIndex.encoding(low);
974 funcStart = pageIndex.functionOffset(low) + sects.dso_base;
975 if (pc < funcStart) {
976 if (log)
977 fprintf(
978 stderr,
979 "\tpc not in table, pc=0x%llX, funcStart=0x%llX, funcEnd=0x%llX\n",
980 (uint64_t) pc, (uint64_t) funcStart, (uint64_t) funcEnd);
981 return false;
982 }
983 if (pc > funcEnd) {
984 if (log)
985 fprintf(
986 stderr,
987 "\tpc not in table, pc=0x%llX, funcStart=0x%llX, funcEnd=0x%llX\n",
988 (uint64_t) pc, (uint64_t) funcStart, (uint64_t) funcEnd);
989 return false;
990 }
991 } else if (pageKind == UNWIND_SECOND_LEVEL_COMPRESSED) {
992 // compressed page
993 UnwindSectionCompressedPageHeader<A> pageHeader(_addressSpace,
994 secondLevelAddr);
995 UnwindSectionCompressedArray<A> pageIndex(
996 _addressSpace, secondLevelAddr + pageHeader.entryPageOffset());
997 const uint32_t targetFunctionPageOffset =
998 (uint32_t)(targetFunctionOffset - firstLevelFunctionOffset);
999 // binary search looks for entry with e where index[e].offset <= pc <
1000 // index[e+1].offset
1001 if (log)
1002 fprintf(stderr, "\tbinary search of compressed page starting at "
1003 "secondLevelAddr=0x%llX\n",
1004 (uint64_t) secondLevelAddr);
1005 low = 0;
1006 last = pageHeader.entryCount() - 1;
1007 high = pageHeader.entryCount();
1008 while (low < high) {
1009 uint32_t mid = (low + high) / 2;
1010 if (pageIndex.functionOffset(mid) <= targetFunctionPageOffset) {
1011 if ((mid == last) ||
1012 (pageIndex.functionOffset(mid + 1) > targetFunctionPageOffset)) {
1013 low = mid;
1014 break;
1015 } else {
1016 low = mid + 1;
1017 }
1018 } else {
1019 high = mid;
1020 }
1021 }
1022 funcStart = pageIndex.functionOffset(low) + firstLevelFunctionOffset
1023 + sects.dso_base;
1024 if (low < last)
1025 funcEnd =
1026 pageIndex.functionOffset(low + 1) + firstLevelFunctionOffset
1027 + sects.dso_base;
1028 else
1029 funcEnd = firstLevelNextPageFunctionOffset + sects.dso_base;
1030 if (pc < funcStart) {
1031 _LIBUNWIND_DEBUG_LOG("malformed __unwind_info, pc=0x%llX not in second "
1032 "level compressed unwind table. funcStart=0x%llX\n",
1033 (uint64_t) pc, (uint64_t) funcStart);
1034 return false;
1035 }
1036 if (pc > funcEnd) {
1037 _LIBUNWIND_DEBUG_LOG("malformed __unwind_info, pc=0x%llX not in second "
1038 "level compressed unwind table. funcEnd=0x%llX\n",
1039 (uint64_t) pc, (uint64_t) funcEnd);
1040 return false;
1041 }
1042 uint16_t encodingIndex = pageIndex.encodingIndex(low);
1043 if (encodingIndex < sectionHeader.commonEncodingsArrayCount()) {
1044 // encoding is in common table in section header
1045 encoding = _addressSpace.get32(
1046 sects.compact_unwind_section +
1047 sectionHeader.commonEncodingsArraySectionOffset() +
1048 encodingIndex * sizeof(uint32_t));
1049 } else {
1050 // encoding is in page specific table
1051 uint16_t pageEncodingIndex =
1052 encodingIndex - (uint16_t)sectionHeader.commonEncodingsArrayCount();
1053 encoding = _addressSpace.get32(secondLevelAddr +
1054 pageHeader.encodingsPageOffset() +
1055 pageEncodingIndex * sizeof(uint32_t));
1056 }
1057 } else {
1058 _LIBUNWIND_DEBUG_LOG("malformed __unwind_info at 0x%0llX bad second "
1059 "level page\n",
1060 (uint64_t) sects.compact_unwind_section);
1061 return false;
1062 }
1063
1064 // look up LSDA, if encoding says function has one
1065 if (encoding & UNWIND_HAS_LSDA) {
1066 UnwindSectionLsdaArray<A> lsdaIndex(_addressSpace, lsdaArrayStartAddr);
1067 uint32_t funcStartOffset = (uint32_t)(funcStart - sects.dso_base);
1068 low = 0;
1069 high = (uint32_t)(lsdaArrayEndAddr - lsdaArrayStartAddr) /
1070 sizeof(unwind_info_section_header_lsda_index_entry);
1071 // binary search looks for entry with exact match for functionOffset
1072 if (log)
1073 fprintf(stderr,
1074 "\tbinary search of lsda table for targetFunctionOffset=0x%08X\n",
1075 funcStartOffset);
1076 while (low < high) {
1077 uint32_t mid = (low + high) / 2;
1078 if (lsdaIndex.functionOffset(mid) == funcStartOffset) {
1079 lsda = lsdaIndex.lsdaOffset(mid) + sects.dso_base;
1080 break;
1081 } else if (lsdaIndex.functionOffset(mid) < funcStartOffset) {
1082 low = mid + 1;
1083 } else {
1084 high = mid;
1085 }
1086 }
1087 if (lsda == 0) {
1088 _LIBUNWIND_DEBUG_LOG("found encoding 0x%08X with HAS_LSDA bit set for "
1089 "pc=0x%0llX, but lsda table has no entry\n",
1090 encoding, (uint64_t) pc);
1091 return false;
1092 }
1093 }
1094
1095 // extact personality routine, if encoding says function has one
1096 uint32_t personalityIndex = (encoding & UNWIND_PERSONALITY_MASK) >>
1097 (__builtin_ctz(UNWIND_PERSONALITY_MASK));
1098 if (personalityIndex != 0) {
1099 --personalityIndex; // change 1-based to zero-based index
1100 if (personalityIndex > sectionHeader.personalityArrayCount()) {
1101 _LIBUNWIND_DEBUG_LOG("found encoding 0x%08X with personality index %d, "
1102 "but personality table has only %d entires\n",
1103 encoding, personalityIndex,
1104 sectionHeader.personalityArrayCount());
1105 return false;
1106 }
1107 int32_t personalityDelta = (int32_t)_addressSpace.get32(
1108 sects.compact_unwind_section +
1109 sectionHeader.personalityArraySectionOffset() +
1110 personalityIndex * sizeof(uint32_t));
1111 pint_t personalityPointer = sects.dso_base + (pint_t)personalityDelta;
1112 personality = _addressSpace.getP(personalityPointer);
1113 if (log)
1114 fprintf(stderr, "getInfoFromCompactEncodingSection(pc=0x%llX), "
1115 "personalityDelta=0x%08X, personality=0x%08llX\n",
1116 (uint64_t) pc, personalityDelta, (uint64_t) personality);
1117 }
1118
1119 if (log)
1120 fprintf(stderr, "getInfoFromCompactEncodingSection(pc=0x%llX), "
1121 "encoding=0x%08X, lsda=0x%08llX for funcStart=0x%llX\n",
1122 (uint64_t) pc, encoding, (uint64_t) lsda, (uint64_t) funcStart);
1123 _info.start_ip = funcStart;
1124 _info.end_ip = funcEnd;
1125 _info.lsda = lsda;
1126 _info.handler = personality;
1127 _info.gp = 0;
1128 _info.flags = 0;
1129 _info.format = encoding;
1130 _info.unwind_info = 0;
1131 _info.unwind_info_size = 0;
1132 _info.extra = sects.dso_base;
1133 return true;
1134 }
1135 #endif // _LIBUNWIND_SUPPORT_COMPACT_UNWIND
1136
1137
1138 template <typename A, typename R>
setInfoBasedOnIPRegister(bool isReturnAddress)1139 void UnwindCursor<A, R>::setInfoBasedOnIPRegister(bool isReturnAddress) {
1140 pint_t pc = (pint_t)this->getReg(UNW_REG_IP);
1141 #if LIBCXXABI_ARM_EHABI
1142 // Remove the thumb bit so the IP represents the actual instruction address.
1143 // This matches the behaviour of _Unwind_GetIP on arm.
1144 pc &= (pint_t)~0x1;
1145 #endif
1146
1147 // If the last line of a function is a "throw" the compiler sometimes
1148 // emits no instructions after the call to __cxa_throw. This means
1149 // the return address is actually the start of the next function.
1150 // To disambiguate this, back up the pc when we know it is a return
1151 // address.
1152 if (isReturnAddress)
1153 --pc;
1154
1155 // Ask address space object to find unwind sections for this pc.
1156 UnwindInfoSections sects;
1157 if (_addressSpace.findUnwindSections(pc, sects)) {
1158 #if _LIBUNWIND_SUPPORT_COMPACT_UNWIND
1159 // If there is a compact unwind encoding table, look there first.
1160 if (sects.compact_unwind_section != 0) {
1161 if (this->getInfoFromCompactEncodingSection(pc, sects)) {
1162 #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
1163 // Found info in table, done unless encoding says to use dwarf.
1164 uint32_t dwarfOffset;
1165 if ((sects.dwarf_section != 0) && compactSaysUseDwarf(&dwarfOffset)) {
1166 if (this->getInfoFromDwarfSection(pc, sects, dwarfOffset)) {
1167 // found info in dwarf, done
1168 return;
1169 }
1170 }
1171 #endif
1172 // If unwind table has entry, but entry says there is no unwind info,
1173 // record that we have no unwind info.
1174 if (_info.format == 0)
1175 _unwindInfoMissing = true;
1176 return;
1177 }
1178 }
1179 #endif // _LIBUNWIND_SUPPORT_COMPACT_UNWIND
1180
1181 #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
1182 // If there is dwarf unwind info, look there next.
1183 if (sects.dwarf_section != 0) {
1184 if (this->getInfoFromDwarfSection(pc, sects)) {
1185 // found info in dwarf, done
1186 return;
1187 }
1188 }
1189 #endif
1190
1191 #if LIBCXXABI_ARM_EHABI
1192 // If there is ARM EHABI unwind info, look there next.
1193 if (sects.arm_section != 0 && this->getInfoFromEHABISection(pc, sects))
1194 return;
1195 #endif
1196 }
1197
1198 #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
1199 // There is no static unwind info for this pc. Look to see if an FDE was
1200 // dynamically registered for it.
1201 pint_t cachedFDE = DwarfFDECache<A>::findFDE(0, pc);
1202 if (cachedFDE != 0) {
1203 CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo;
1204 CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo;
1205 const char *msg = CFI_Parser<A>::decodeFDE(_addressSpace,
1206 cachedFDE, &fdeInfo, &cieInfo);
1207 if (msg == NULL) {
1208 typename CFI_Parser<A>::PrologInfo prolog;
1209 if (CFI_Parser<A>::parseFDEInstructions(_addressSpace, fdeInfo, cieInfo,
1210 pc, &prolog)) {
1211 // save off parsed FDE info
1212 _info.start_ip = fdeInfo.pcStart;
1213 _info.end_ip = fdeInfo.pcEnd;
1214 _info.lsda = fdeInfo.lsda;
1215 _info.handler = cieInfo.personality;
1216 _info.gp = prolog.spExtraArgSize;
1217 // Some frameless functions need SP
1218 // altered when resuming in function.
1219 _info.flags = 0;
1220 _info.format = dwarfEncoding();
1221 _info.unwind_info = fdeInfo.fdeStart;
1222 _info.unwind_info_size = (uint32_t)fdeInfo.fdeLength;
1223 _info.extra = 0;
1224 return;
1225 }
1226 }
1227 }
1228
1229 // Lastly, ask AddressSpace object about platform specific ways to locate
1230 // other FDEs.
1231 pint_t fde;
1232 if (_addressSpace.findOtherFDE(pc, fde)) {
1233 CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo;
1234 CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo;
1235 if (!CFI_Parser<A>::decodeFDE(_addressSpace, fde, &fdeInfo, &cieInfo)) {
1236 // Double check this FDE is for a function that includes the pc.
1237 if ((fdeInfo.pcStart <= pc) && (pc < fdeInfo.pcEnd)) {
1238 typename CFI_Parser<A>::PrologInfo prolog;
1239 if (CFI_Parser<A>::parseFDEInstructions(_addressSpace, fdeInfo,
1240 cieInfo, pc, &prolog)) {
1241 // save off parsed FDE info
1242 _info.start_ip = fdeInfo.pcStart;
1243 _info.end_ip = fdeInfo.pcEnd;
1244 _info.lsda = fdeInfo.lsda;
1245 _info.handler = cieInfo.personality;
1246 _info.gp = prolog.spExtraArgSize;
1247 _info.flags = 0;
1248 _info.format = dwarfEncoding();
1249 _info.unwind_info = fdeInfo.fdeStart;
1250 _info.unwind_info_size = (uint32_t)fdeInfo.fdeLength;
1251 _info.extra = 0;
1252 return;
1253 }
1254 }
1255 }
1256 }
1257 #endif // #if _LIBUNWIND_SUPPORT_DWARF_UNWIND
1258
1259 // no unwind info, flag that we can't reliably unwind
1260 _unwindInfoMissing = true;
1261 }
1262
1263 template <typename A, typename R>
step()1264 int UnwindCursor<A, R>::step() {
1265 // Bottom of stack is defined is when unwind info cannot be found.
1266 if (_unwindInfoMissing)
1267 return UNW_STEP_END;
1268
1269 // Use unwinding info to modify register set as if function returned.
1270 int result;
1271 #if _LIBUNWIND_SUPPORT_COMPACT_UNWIND
1272 result = this->stepWithCompactEncoding();
1273 #elif _LIBUNWIND_SUPPORT_DWARF_UNWIND
1274 result = this->stepWithDwarfFDE();
1275 #elif LIBCXXABI_ARM_EHABI
1276 result = UNW_STEP_SUCCESS;
1277 #elif defined(__i386__) || defined(__x86_64__) || defined(__mips__) || defined(__mips64)
1278 // ToDo: really?
1279 result = UNW_STEP_SUCCESS;
1280 #else
1281 #error Need _LIBUNWIND_SUPPORT_COMPACT_UNWIND or \
1282 _LIBUNWIND_SUPPORT_DWARF_UNWIND or \
1283 LIBCXXABI_ARM_EHABI
1284 #endif
1285
1286 // update info based on new PC
1287 if (result == UNW_STEP_SUCCESS) {
1288 this->setInfoBasedOnIPRegister(true);
1289 if (_unwindInfoMissing)
1290 return UNW_STEP_END;
1291 if (_info.gp)
1292 setReg(UNW_REG_SP, getReg(UNW_REG_SP) + _info.gp);
1293 }
1294
1295 return result;
1296 }
1297
1298 template <typename A, typename R>
getInfo(unw_proc_info_t * info)1299 void UnwindCursor<A, R>::getInfo(unw_proc_info_t *info) {
1300 *info = _info;
1301 }
1302
1303 template <typename A, typename R>
getFunctionName(char * buf,size_t bufLen,unw_word_t * offset)1304 bool UnwindCursor<A, R>::getFunctionName(char *buf, size_t bufLen,
1305 unw_word_t *offset) {
1306 return _addressSpace.findFunctionName((pint_t)this->getReg(UNW_REG_IP),
1307 buf, bufLen, offset);
1308 }
1309
1310 }; // namespace libunwind
1311
1312 #endif // __UNWINDCURSOR_HPP__
1313