blob: ab2f542dbdfbfb0a2e28bb58672769c1eb13d1c5 [file] [log] [blame]
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001//===------------------------- 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//
Ed Maste6f723382016-08-30 13:08:21 +00009// C++ interface to lower levels of libunwind
Saleem Abdulrasool17552662015-04-24 19:39:17 +000010//===----------------------------------------------------------------------===//
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>
Saleem Abdulrasool17552662015-04-24 19:39:17 +000019#include <unwind.h>
20
21#ifdef __APPLE__
22 #include <mach-o/dyld.h>
23#endif
24
25#include "config.h"
26
27#include "AddressSpace.hpp"
28#include "CompactUnwinder.hpp"
29#include "config.h"
30#include "DwarfInstructions.hpp"
31#include "EHHeaderParser.hpp"
32#include "libunwind.h"
33#include "Registers.hpp"
Martin Storsjo590ffef2017-10-23 19:29:36 +000034#include "RWMutex.hpp"
Saleem Abdulrasool17552662015-04-24 19:39:17 +000035#include "Unwind-EHABI.h"
36
37namespace libunwind {
38
Ranjeet Singh421231a2017-03-31 15:28:06 +000039#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +000040/// Cache of recently found FDEs.
41template <typename A>
42class _LIBUNWIND_HIDDEN DwarfFDECache {
43 typedef typename A::pint_t pint_t;
44public:
45 static pint_t findFDE(pint_t mh, pint_t pc);
46 static void add(pint_t mh, pint_t ip_start, pint_t ip_end, pint_t fde);
47 static void removeAllIn(pint_t mh);
48 static void iterateCacheEntries(void (*func)(unw_word_t ip_start,
49 unw_word_t ip_end,
50 unw_word_t fde, unw_word_t mh));
51
52private:
53
54 struct entry {
55 pint_t mh;
56 pint_t ip_start;
57 pint_t ip_end;
58 pint_t fde;
59 };
60
61 // These fields are all static to avoid needing an initializer.
62 // There is only one instance of this class per process.
Martin Storsjo590ffef2017-10-23 19:29:36 +000063 static RWMutex _lock;
Saleem Abdulrasool17552662015-04-24 19:39:17 +000064#ifdef __APPLE__
65 static void dyldUnloadHook(const struct mach_header *mh, intptr_t slide);
66 static bool _registeredForDyldUnloads;
67#endif
68 // Can't use std::vector<> here because this code is below libc++.
69 static entry *_buffer;
70 static entry *_bufferUsed;
71 static entry *_bufferEnd;
72 static entry _initialBuffer[64];
73};
74
75template <typename A>
76typename DwarfFDECache<A>::entry *
77DwarfFDECache<A>::_buffer = _initialBuffer;
78
79template <typename A>
80typename DwarfFDECache<A>::entry *
81DwarfFDECache<A>::_bufferUsed = _initialBuffer;
82
83template <typename A>
84typename DwarfFDECache<A>::entry *
85DwarfFDECache<A>::_bufferEnd = &_initialBuffer[64];
86
87template <typename A>
88typename DwarfFDECache<A>::entry DwarfFDECache<A>::_initialBuffer[64];
89
90template <typename A>
Martin Storsjo590ffef2017-10-23 19:29:36 +000091RWMutex DwarfFDECache<A>::_lock;
Saleem Abdulrasool17552662015-04-24 19:39:17 +000092
93#ifdef __APPLE__
94template <typename A>
95bool DwarfFDECache<A>::_registeredForDyldUnloads = false;
96#endif
97
98template <typename A>
99typename A::pint_t DwarfFDECache<A>::findFDE(pint_t mh, pint_t pc) {
100 pint_t result = 0;
Martin Storsjo590ffef2017-10-23 19:29:36 +0000101 _LIBUNWIND_LOG_IF_FALSE(_lock.lock_shared());
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000102 for (entry *p = _buffer; p < _bufferUsed; ++p) {
103 if ((mh == p->mh) || (mh == 0)) {
104 if ((p->ip_start <= pc) && (pc < p->ip_end)) {
105 result = p->fde;
106 break;
107 }
108 }
109 }
Martin Storsjo590ffef2017-10-23 19:29:36 +0000110 _LIBUNWIND_LOG_IF_FALSE(_lock.unlock_shared());
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000111 return result;
112}
113
114template <typename A>
115void DwarfFDECache<A>::add(pint_t mh, pint_t ip_start, pint_t ip_end,
116 pint_t fde) {
Peter Zotov0717a2e2015-11-09 06:57:29 +0000117#if !defined(_LIBUNWIND_NO_HEAP)
Martin Storsjo590ffef2017-10-23 19:29:36 +0000118 _LIBUNWIND_LOG_IF_FALSE(_lock.lock());
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000119 if (_bufferUsed >= _bufferEnd) {
120 size_t oldSize = (size_t)(_bufferEnd - _buffer);
121 size_t newSize = oldSize * 4;
122 // Can't use operator new (we are below it).
123 entry *newBuffer = (entry *)malloc(newSize * sizeof(entry));
124 memcpy(newBuffer, _buffer, oldSize * sizeof(entry));
125 if (_buffer != _initialBuffer)
126 free(_buffer);
127 _buffer = newBuffer;
128 _bufferUsed = &newBuffer[oldSize];
129 _bufferEnd = &newBuffer[newSize];
130 }
131 _bufferUsed->mh = mh;
132 _bufferUsed->ip_start = ip_start;
133 _bufferUsed->ip_end = ip_end;
134 _bufferUsed->fde = fde;
135 ++_bufferUsed;
136#ifdef __APPLE__
137 if (!_registeredForDyldUnloads) {
138 _dyld_register_func_for_remove_image(&dyldUnloadHook);
139 _registeredForDyldUnloads = true;
140 }
141#endif
Martin Storsjo590ffef2017-10-23 19:29:36 +0000142 _LIBUNWIND_LOG_IF_FALSE(_lock.unlock());
Peter Zotov0717a2e2015-11-09 06:57:29 +0000143#endif
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000144}
145
146template <typename A>
147void DwarfFDECache<A>::removeAllIn(pint_t mh) {
Martin Storsjo590ffef2017-10-23 19:29:36 +0000148 _LIBUNWIND_LOG_IF_FALSE(_lock.lock());
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000149 entry *d = _buffer;
150 for (const entry *s = _buffer; s < _bufferUsed; ++s) {
151 if (s->mh != mh) {
152 if (d != s)
153 *d = *s;
154 ++d;
155 }
156 }
157 _bufferUsed = d;
Martin Storsjo590ffef2017-10-23 19:29:36 +0000158 _LIBUNWIND_LOG_IF_FALSE(_lock.unlock());
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000159}
160
161#ifdef __APPLE__
162template <typename A>
163void DwarfFDECache<A>::dyldUnloadHook(const struct mach_header *mh, intptr_t ) {
164 removeAllIn((pint_t) mh);
165}
166#endif
167
168template <typename A>
169void DwarfFDECache<A>::iterateCacheEntries(void (*func)(
170 unw_word_t ip_start, unw_word_t ip_end, unw_word_t fde, unw_word_t mh)) {
Martin Storsjo590ffef2017-10-23 19:29:36 +0000171 _LIBUNWIND_LOG_IF_FALSE(_lock.lock());
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000172 for (entry *p = _buffer; p < _bufferUsed; ++p) {
173 (*func)(p->ip_start, p->ip_end, p->fde, p->mh);
174 }
Martin Storsjo590ffef2017-10-23 19:29:36 +0000175 _LIBUNWIND_LOG_IF_FALSE(_lock.unlock());
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000176}
Ranjeet Singh421231a2017-03-31 15:28:06 +0000177#endif // defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000178
179
180#define arrayoffsetof(type, index, field) ((size_t)(&((type *)0)[index].field))
181
Ranjeet Singh421231a2017-03-31 15:28:06 +0000182#if defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000183template <typename A> class UnwindSectionHeader {
184public:
185 UnwindSectionHeader(A &addressSpace, typename A::pint_t addr)
186 : _addressSpace(addressSpace), _addr(addr) {}
187
188 uint32_t version() const {
189 return _addressSpace.get32(_addr +
190 offsetof(unwind_info_section_header, version));
191 }
192 uint32_t commonEncodingsArraySectionOffset() const {
193 return _addressSpace.get32(_addr +
194 offsetof(unwind_info_section_header,
195 commonEncodingsArraySectionOffset));
196 }
197 uint32_t commonEncodingsArrayCount() const {
198 return _addressSpace.get32(_addr + offsetof(unwind_info_section_header,
199 commonEncodingsArrayCount));
200 }
201 uint32_t personalityArraySectionOffset() const {
202 return _addressSpace.get32(_addr + offsetof(unwind_info_section_header,
203 personalityArraySectionOffset));
204 }
205 uint32_t personalityArrayCount() const {
206 return _addressSpace.get32(
207 _addr + offsetof(unwind_info_section_header, personalityArrayCount));
208 }
209 uint32_t indexSectionOffset() const {
210 return _addressSpace.get32(
211 _addr + offsetof(unwind_info_section_header, indexSectionOffset));
212 }
213 uint32_t indexCount() const {
214 return _addressSpace.get32(
215 _addr + offsetof(unwind_info_section_header, indexCount));
216 }
217
218private:
219 A &_addressSpace;
220 typename A::pint_t _addr;
221};
222
223template <typename A> class UnwindSectionIndexArray {
224public:
225 UnwindSectionIndexArray(A &addressSpace, typename A::pint_t addr)
226 : _addressSpace(addressSpace), _addr(addr) {}
227
228 uint32_t functionOffset(uint32_t index) const {
229 return _addressSpace.get32(
230 _addr + arrayoffsetof(unwind_info_section_header_index_entry, index,
231 functionOffset));
232 }
233 uint32_t secondLevelPagesSectionOffset(uint32_t index) const {
234 return _addressSpace.get32(
235 _addr + arrayoffsetof(unwind_info_section_header_index_entry, index,
236 secondLevelPagesSectionOffset));
237 }
238 uint32_t lsdaIndexArraySectionOffset(uint32_t index) const {
239 return _addressSpace.get32(
240 _addr + arrayoffsetof(unwind_info_section_header_index_entry, index,
241 lsdaIndexArraySectionOffset));
242 }
243
244private:
245 A &_addressSpace;
246 typename A::pint_t _addr;
247};
248
249template <typename A> class UnwindSectionRegularPageHeader {
250public:
251 UnwindSectionRegularPageHeader(A &addressSpace, typename A::pint_t addr)
252 : _addressSpace(addressSpace), _addr(addr) {}
253
254 uint32_t kind() const {
255 return _addressSpace.get32(
256 _addr + offsetof(unwind_info_regular_second_level_page_header, kind));
257 }
258 uint16_t entryPageOffset() const {
259 return _addressSpace.get16(
260 _addr + offsetof(unwind_info_regular_second_level_page_header,
261 entryPageOffset));
262 }
263 uint16_t entryCount() const {
264 return _addressSpace.get16(
265 _addr +
266 offsetof(unwind_info_regular_second_level_page_header, entryCount));
267 }
268
269private:
270 A &_addressSpace;
271 typename A::pint_t _addr;
272};
273
274template <typename A> class UnwindSectionRegularArray {
275public:
276 UnwindSectionRegularArray(A &addressSpace, typename A::pint_t addr)
277 : _addressSpace(addressSpace), _addr(addr) {}
278
279 uint32_t functionOffset(uint32_t index) const {
280 return _addressSpace.get32(
281 _addr + arrayoffsetof(unwind_info_regular_second_level_entry, index,
282 functionOffset));
283 }
284 uint32_t encoding(uint32_t index) const {
285 return _addressSpace.get32(
286 _addr +
287 arrayoffsetof(unwind_info_regular_second_level_entry, index, encoding));
288 }
289
290private:
291 A &_addressSpace;
292 typename A::pint_t _addr;
293};
294
295template <typename A> class UnwindSectionCompressedPageHeader {
296public:
297 UnwindSectionCompressedPageHeader(A &addressSpace, typename A::pint_t addr)
298 : _addressSpace(addressSpace), _addr(addr) {}
299
300 uint32_t kind() const {
301 return _addressSpace.get32(
302 _addr +
303 offsetof(unwind_info_compressed_second_level_page_header, kind));
304 }
305 uint16_t entryPageOffset() const {
306 return _addressSpace.get16(
307 _addr + offsetof(unwind_info_compressed_second_level_page_header,
308 entryPageOffset));
309 }
310 uint16_t entryCount() const {
311 return _addressSpace.get16(
312 _addr +
313 offsetof(unwind_info_compressed_second_level_page_header, entryCount));
314 }
315 uint16_t encodingsPageOffset() const {
316 return _addressSpace.get16(
317 _addr + offsetof(unwind_info_compressed_second_level_page_header,
318 encodingsPageOffset));
319 }
320 uint16_t encodingsCount() const {
321 return _addressSpace.get16(
322 _addr + offsetof(unwind_info_compressed_second_level_page_header,
323 encodingsCount));
324 }
325
326private:
327 A &_addressSpace;
328 typename A::pint_t _addr;
329};
330
331template <typename A> class UnwindSectionCompressedArray {
332public:
333 UnwindSectionCompressedArray(A &addressSpace, typename A::pint_t addr)
334 : _addressSpace(addressSpace), _addr(addr) {}
335
336 uint32_t functionOffset(uint32_t index) const {
337 return UNWIND_INFO_COMPRESSED_ENTRY_FUNC_OFFSET(
338 _addressSpace.get32(_addr + index * sizeof(uint32_t)));
339 }
340 uint16_t encodingIndex(uint32_t index) const {
341 return UNWIND_INFO_COMPRESSED_ENTRY_ENCODING_INDEX(
342 _addressSpace.get32(_addr + index * sizeof(uint32_t)));
343 }
344
345private:
346 A &_addressSpace;
347 typename A::pint_t _addr;
348};
349
350template <typename A> class UnwindSectionLsdaArray {
351public:
352 UnwindSectionLsdaArray(A &addressSpace, typename A::pint_t addr)
353 : _addressSpace(addressSpace), _addr(addr) {}
354
355 uint32_t functionOffset(uint32_t index) const {
356 return _addressSpace.get32(
357 _addr + arrayoffsetof(unwind_info_section_header_lsda_index_entry,
358 index, functionOffset));
359 }
360 uint32_t lsdaOffset(uint32_t index) const {
361 return _addressSpace.get32(
362 _addr + arrayoffsetof(unwind_info_section_header_lsda_index_entry,
363 index, lsdaOffset));
364 }
365
366private:
367 A &_addressSpace;
368 typename A::pint_t _addr;
369};
Ranjeet Singh421231a2017-03-31 15:28:06 +0000370#endif // defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000371
372class _LIBUNWIND_HIDDEN AbstractUnwindCursor {
373public:
374 // NOTE: provide a class specific placement deallocation function (S5.3.4 p20)
375 // This avoids an unnecessary dependency to libc++abi.
376 void operator delete(void *, size_t) {}
377
378 virtual ~AbstractUnwindCursor() {}
379 virtual bool validReg(int) { _LIBUNWIND_ABORT("validReg not implemented"); }
380 virtual unw_word_t getReg(int) { _LIBUNWIND_ABORT("getReg not implemented"); }
381 virtual void setReg(int, unw_word_t) {
382 _LIBUNWIND_ABORT("setReg not implemented");
383 }
384 virtual bool validFloatReg(int) {
385 _LIBUNWIND_ABORT("validFloatReg not implemented");
386 }
387 virtual unw_fpreg_t getFloatReg(int) {
388 _LIBUNWIND_ABORT("getFloatReg not implemented");
389 }
390 virtual void setFloatReg(int, unw_fpreg_t) {
391 _LIBUNWIND_ABORT("setFloatReg not implemented");
392 }
393 virtual int step() { _LIBUNWIND_ABORT("step not implemented"); }
394 virtual void getInfo(unw_proc_info_t *) {
395 _LIBUNWIND_ABORT("getInfo not implemented");
396 }
397 virtual void jumpto() { _LIBUNWIND_ABORT("jumpto not implemented"); }
398 virtual bool isSignalFrame() {
399 _LIBUNWIND_ABORT("isSignalFrame not implemented");
400 }
401 virtual bool getFunctionName(char *, size_t, unw_word_t *) {
402 _LIBUNWIND_ABORT("getFunctionName not implemented");
403 }
404 virtual void setInfoBasedOnIPRegister(bool = false) {
405 _LIBUNWIND_ABORT("setInfoBasedOnIPRegister not implemented");
406 }
407 virtual const char *getRegisterName(int) {
408 _LIBUNWIND_ABORT("getRegisterName not implemented");
409 }
410#ifdef __arm__
411 virtual void saveVFPAsX() { _LIBUNWIND_ABORT("saveVFPAsX not implemented"); }
412#endif
413};
414
415/// UnwindCursor contains all state (including all register values) during
416/// an unwind. This is normally stack allocated inside a unw_cursor_t.
417template <typename A, typename R>
418class UnwindCursor : public AbstractUnwindCursor{
419 typedef typename A::pint_t pint_t;
420public:
421 UnwindCursor(unw_context_t *context, A &as);
422 UnwindCursor(A &as, void *threadArg);
423 virtual ~UnwindCursor() {}
424 virtual bool validReg(int);
425 virtual unw_word_t getReg(int);
426 virtual void setReg(int, unw_word_t);
427 virtual bool validFloatReg(int);
428 virtual unw_fpreg_t getFloatReg(int);
429 virtual void setFloatReg(int, unw_fpreg_t);
430 virtual int step();
431 virtual void getInfo(unw_proc_info_t *);
432 virtual void jumpto();
433 virtual bool isSignalFrame();
434 virtual bool getFunctionName(char *buf, size_t len, unw_word_t *off);
435 virtual void setInfoBasedOnIPRegister(bool isReturnAddress = false);
436 virtual const char *getRegisterName(int num);
437#ifdef __arm__
438 virtual void saveVFPAsX();
439#endif
440
441private:
442
Ranjeet Singh421231a2017-03-31 15:28:06 +0000443#if defined(_LIBUNWIND_ARM_EHABI)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000444 bool getInfoFromEHABISection(pint_t pc, const UnwindInfoSections &sects);
Logan Chiena54f0962015-05-29 15:33:38 +0000445
446 int stepWithEHABI() {
447 size_t len = 0;
448 size_t off = 0;
449 // FIXME: Calling decode_eht_entry() here is violating the libunwind
450 // abstraction layer.
451 const uint32_t *ehtp =
452 decode_eht_entry(reinterpret_cast<const uint32_t *>(_info.unwind_info),
453 &off, &len);
454 if (_Unwind_VRS_Interpret((_Unwind_Context *)this, ehtp, off, len) !=
455 _URC_CONTINUE_UNWIND)
456 return UNW_STEP_END;
457 return UNW_STEP_SUCCESS;
458 }
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000459#endif
460
Ranjeet Singh421231a2017-03-31 15:28:06 +0000461#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000462 bool getInfoFromDwarfSection(pint_t pc, const UnwindInfoSections &sects,
463 uint32_t fdeSectionOffsetHint=0);
464 int stepWithDwarfFDE() {
465 return DwarfInstructions<A, R>::stepWithDwarf(_addressSpace,
466 (pint_t)this->getReg(UNW_REG_IP),
467 (pint_t)_info.unwind_info,
468 _registers);
469 }
470#endif
471
Ranjeet Singh421231a2017-03-31 15:28:06 +0000472#if defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000473 bool getInfoFromCompactEncodingSection(pint_t pc,
474 const UnwindInfoSections &sects);
475 int stepWithCompactEncoding() {
Ranjeet Singh421231a2017-03-31 15:28:06 +0000476 #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000477 if ( compactSaysUseDwarf() )
478 return stepWithDwarfFDE();
479 #endif
480 R dummy;
481 return stepWithCompactEncoding(dummy);
482 }
483
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000484#if defined(_LIBUNWIND_TARGET_X86_64)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000485 int stepWithCompactEncoding(Registers_x86_64 &) {
486 return CompactUnwinder_x86_64<A>::stepWithCompactEncoding(
487 _info.format, _info.start_ip, _addressSpace, _registers);
488 }
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000489#endif
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000490
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000491#if defined(_LIBUNWIND_TARGET_I386)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000492 int stepWithCompactEncoding(Registers_x86 &) {
493 return CompactUnwinder_x86<A>::stepWithCompactEncoding(
494 _info.format, (uint32_t)_info.start_ip, _addressSpace, _registers);
495 }
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000496#endif
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000497
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000498#if defined(_LIBUNWIND_TARGET_PPC)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000499 int stepWithCompactEncoding(Registers_ppc &) {
500 return UNW_EINVAL;
501 }
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000502#endif
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000503
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000504#if defined(_LIBUNWIND_TARGET_AARCH64)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000505 int stepWithCompactEncoding(Registers_arm64 &) {
506 return CompactUnwinder_arm64<A>::stepWithCompactEncoding(
507 _info.format, _info.start_ip, _addressSpace, _registers);
508 }
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000509#endif
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000510
511 bool compactSaysUseDwarf(uint32_t *offset=NULL) const {
512 R dummy;
513 return compactSaysUseDwarf(dummy, offset);
514 }
515
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000516#if defined(_LIBUNWIND_TARGET_X86_64)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000517 bool compactSaysUseDwarf(Registers_x86_64 &, uint32_t *offset) const {
518 if ((_info.format & UNWIND_X86_64_MODE_MASK) == UNWIND_X86_64_MODE_DWARF) {
519 if (offset)
520 *offset = (_info.format & UNWIND_X86_64_DWARF_SECTION_OFFSET);
521 return true;
522 }
523 return false;
524 }
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000525#endif
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000526
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000527#if defined(_LIBUNWIND_TARGET_I386)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000528 bool compactSaysUseDwarf(Registers_x86 &, uint32_t *offset) const {
529 if ((_info.format & UNWIND_X86_MODE_MASK) == UNWIND_X86_MODE_DWARF) {
530 if (offset)
531 *offset = (_info.format & UNWIND_X86_DWARF_SECTION_OFFSET);
532 return true;
533 }
534 return false;
535 }
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000536#endif
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000537
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000538#if defined(_LIBUNWIND_TARGET_PPC)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000539 bool compactSaysUseDwarf(Registers_ppc &, uint32_t *) const {
540 return true;
541 }
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000542#endif
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000543
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000544#if defined(_LIBUNWIND_TARGET_AARCH64)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000545 bool compactSaysUseDwarf(Registers_arm64 &, uint32_t *offset) const {
546 if ((_info.format & UNWIND_ARM64_MODE_MASK) == UNWIND_ARM64_MODE_DWARF) {
547 if (offset)
548 *offset = (_info.format & UNWIND_ARM64_DWARF_SECTION_OFFSET);
549 return true;
550 }
551 return false;
552 }
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000553#endif
Ranjeet Singh421231a2017-03-31 15:28:06 +0000554#endif // defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000555
Ranjeet Singh421231a2017-03-31 15:28:06 +0000556#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000557 compact_unwind_encoding_t dwarfEncoding() const {
558 R dummy;
559 return dwarfEncoding(dummy);
560 }
561
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000562#if defined(_LIBUNWIND_TARGET_X86_64)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000563 compact_unwind_encoding_t dwarfEncoding(Registers_x86_64 &) const {
564 return UNWIND_X86_64_MODE_DWARF;
565 }
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000566#endif
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000567
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000568#if defined(_LIBUNWIND_TARGET_I386)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000569 compact_unwind_encoding_t dwarfEncoding(Registers_x86 &) const {
570 return UNWIND_X86_MODE_DWARF;
571 }
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000572#endif
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000573
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000574#if defined(_LIBUNWIND_TARGET_PPC)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000575 compact_unwind_encoding_t dwarfEncoding(Registers_ppc &) const {
576 return 0;
577 }
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000578#endif
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000579
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000580#if defined(_LIBUNWIND_TARGET_AARCH64)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000581 compact_unwind_encoding_t dwarfEncoding(Registers_arm64 &) const {
582 return UNWIND_ARM64_MODE_DWARF;
583 }
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000584#endif
Peter Zotov8d639992015-08-31 05:26:37 +0000585
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000586#if defined (_LIBUNWIND_TARGET_OR1K)
Peter Zotov8d639992015-08-31 05:26:37 +0000587 compact_unwind_encoding_t dwarfEncoding(Registers_or1k &) const {
588 return 0;
589 }
Asiri Rathnayakec00dcef2016-05-25 12:36:34 +0000590#endif
Ranjeet Singh421231a2017-03-31 15:28:06 +0000591#endif // defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000592
593
594 A &_addressSpace;
595 R _registers;
596 unw_proc_info_t _info;
597 bool _unwindInfoMissing;
598 bool _isSignalFrame;
599};
600
601
602template <typename A, typename R>
603UnwindCursor<A, R>::UnwindCursor(unw_context_t *context, A &as)
604 : _addressSpace(as), _registers(context), _unwindInfoMissing(false),
605 _isSignalFrame(false) {
Asiri Rathnayake74d35252016-05-26 21:45:54 +0000606 static_assert((check_fit<UnwindCursor<A, R>, unw_cursor_t>::does_fit),
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000607 "UnwindCursor<> does not fit in unw_cursor_t");
608 memset(&_info, 0, sizeof(_info));
609}
610
611template <typename A, typename R>
612UnwindCursor<A, R>::UnwindCursor(A &as, void *)
613 : _addressSpace(as), _unwindInfoMissing(false), _isSignalFrame(false) {
614 memset(&_info, 0, sizeof(_info));
615 // FIXME
616 // fill in _registers from thread arg
617}
618
619
620template <typename A, typename R>
621bool UnwindCursor<A, R>::validReg(int regNum) {
622 return _registers.validRegister(regNum);
623}
624
625template <typename A, typename R>
626unw_word_t UnwindCursor<A, R>::getReg(int regNum) {
627 return _registers.getRegister(regNum);
628}
629
630template <typename A, typename R>
631void UnwindCursor<A, R>::setReg(int regNum, unw_word_t value) {
632 _registers.setRegister(regNum, (typename A::pint_t)value);
633}
634
635template <typename A, typename R>
636bool UnwindCursor<A, R>::validFloatReg(int regNum) {
637 return _registers.validFloatRegister(regNum);
638}
639
640template <typename A, typename R>
641unw_fpreg_t UnwindCursor<A, R>::getFloatReg(int regNum) {
642 return _registers.getFloatRegister(regNum);
643}
644
645template <typename A, typename R>
646void UnwindCursor<A, R>::setFloatReg(int regNum, unw_fpreg_t value) {
647 _registers.setFloatRegister(regNum, value);
648}
649
650template <typename A, typename R> void UnwindCursor<A, R>::jumpto() {
651 _registers.jumpto();
652}
653
654#ifdef __arm__
655template <typename A, typename R> void UnwindCursor<A, R>::saveVFPAsX() {
656 _registers.saveVFPAsX();
657}
658#endif
659
660template <typename A, typename R>
661const char *UnwindCursor<A, R>::getRegisterName(int regNum) {
662 return _registers.getRegisterName(regNum);
663}
664
665template <typename A, typename R> bool UnwindCursor<A, R>::isSignalFrame() {
666 return _isSignalFrame;
667}
668
Ranjeet Singh421231a2017-03-31 15:28:06 +0000669#if defined(_LIBUNWIND_ARM_EHABI)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000670struct EHABIIndexEntry {
671 uint32_t functionOffset;
672 uint32_t data;
673};
674
675template<typename A>
676struct EHABISectionIterator {
677 typedef EHABISectionIterator _Self;
678
679 typedef std::random_access_iterator_tag iterator_category;
680 typedef typename A::pint_t value_type;
681 typedef typename A::pint_t* pointer;
682 typedef typename A::pint_t& reference;
683 typedef size_t size_type;
684 typedef size_t difference_type;
685
686 static _Self begin(A& addressSpace, const UnwindInfoSections& sects) {
687 return _Self(addressSpace, sects, 0);
688 }
689 static _Self end(A& addressSpace, const UnwindInfoSections& sects) {
Ed Schouten5d3f35b2017-03-07 15:21:57 +0000690 return _Self(addressSpace, sects,
691 sects.arm_section_length / sizeof(EHABIIndexEntry));
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000692 }
693
694 EHABISectionIterator(A& addressSpace, const UnwindInfoSections& sects, size_t i)
695 : _i(i), _addressSpace(&addressSpace), _sects(&sects) {}
696
697 _Self& operator++() { ++_i; return *this; }
698 _Self& operator+=(size_t a) { _i += a; return *this; }
699 _Self& operator--() { assert(_i > 0); --_i; return *this; }
700 _Self& operator-=(size_t a) { assert(_i >= a); _i -= a; return *this; }
701
702 _Self operator+(size_t a) { _Self out = *this; out._i += a; return out; }
703 _Self operator-(size_t a) { assert(_i >= a); _Self out = *this; out._i -= a; return out; }
704
705 size_t operator-(const _Self& other) { return _i - other._i; }
706
707 bool operator==(const _Self& other) const {
708 assert(_addressSpace == other._addressSpace);
709 assert(_sects == other._sects);
710 return _i == other._i;
711 }
712
713 typename A::pint_t operator*() const { return functionAddress(); }
714
715 typename A::pint_t functionAddress() const {
716 typename A::pint_t indexAddr = _sects->arm_section + arrayoffsetof(
717 EHABIIndexEntry, _i, functionOffset);
718 return indexAddr + signExtendPrel31(_addressSpace->get32(indexAddr));
719 }
720
721 typename A::pint_t dataAddress() {
722 typename A::pint_t indexAddr = _sects->arm_section + arrayoffsetof(
723 EHABIIndexEntry, _i, data);
724 return indexAddr;
725 }
726
727 private:
728 size_t _i;
729 A* _addressSpace;
730 const UnwindInfoSections* _sects;
731};
732
733template <typename A, typename R>
734bool UnwindCursor<A, R>::getInfoFromEHABISection(
735 pint_t pc,
736 const UnwindInfoSections &sects) {
737 EHABISectionIterator<A> begin =
738 EHABISectionIterator<A>::begin(_addressSpace, sects);
739 EHABISectionIterator<A> end =
740 EHABISectionIterator<A>::end(_addressSpace, sects);
Momchil Velikov064d69a2017-07-24 09:19:32 +0000741 if (begin == end)
742 return false;
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000743
744 EHABISectionIterator<A> itNextPC = std::upper_bound(begin, end, pc);
Momchil Velikov064d69a2017-07-24 09:19:32 +0000745 if (itNextPC == begin)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000746 return false;
747 EHABISectionIterator<A> itThisPC = itNextPC - 1;
748
749 pint_t thisPC = itThisPC.functionAddress();
Momchil Velikov064d69a2017-07-24 09:19:32 +0000750 // If an exception is thrown from a function, corresponding to the last entry
751 // in the table, we don't really know the function extent and have to choose a
752 // value for nextPC. Choosing max() will allow the range check during trace to
753 // succeed.
754 pint_t nextPC = (itNextPC == end) ? std::numeric_limits<pint_t>::max()
755 : itNextPC.functionAddress();
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000756 pint_t indexDataAddr = itThisPC.dataAddress();
757
758 if (indexDataAddr == 0)
759 return false;
760
761 uint32_t indexData = _addressSpace.get32(indexDataAddr);
762 if (indexData == UNW_EXIDX_CANTUNWIND)
763 return false;
764
765 // If the high bit is set, the exception handling table entry is inline inside
766 // the index table entry on the second word (aka |indexDataAddr|). Otherwise,
767 // the table points at an offset in the exception handling table (section 5 EHABI).
768 pint_t exceptionTableAddr;
769 uint32_t exceptionTableData;
770 bool isSingleWordEHT;
771 if (indexData & 0x80000000) {
772 exceptionTableAddr = indexDataAddr;
773 // TODO(ajwong): Should this data be 0?
774 exceptionTableData = indexData;
775 isSingleWordEHT = true;
776 } else {
777 exceptionTableAddr = indexDataAddr + signExtendPrel31(indexData);
778 exceptionTableData = _addressSpace.get32(exceptionTableAddr);
779 isSingleWordEHT = false;
780 }
781
782 // Now we know the 3 things:
783 // exceptionTableAddr -- exception handler table entry.
784 // exceptionTableData -- the data inside the first word of the eht entry.
785 // isSingleWordEHT -- whether the entry is in the index.
786 unw_word_t personalityRoutine = 0xbadf00d;
787 bool scope32 = false;
Logan Chiena54f0962015-05-29 15:33:38 +0000788 uintptr_t lsda;
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000789
790 // If the high bit in the exception handling table entry is set, the entry is
791 // in compact form (section 6.3 EHABI).
792 if (exceptionTableData & 0x80000000) {
793 // Grab the index of the personality routine from the compact form.
794 uint32_t choice = (exceptionTableData & 0x0f000000) >> 24;
795 uint32_t extraWords = 0;
796 switch (choice) {
797 case 0:
798 personalityRoutine = (unw_word_t) &__aeabi_unwind_cpp_pr0;
799 extraWords = 0;
800 scope32 = false;
Logan Chiena54f0962015-05-29 15:33:38 +0000801 lsda = isSingleWordEHT ? 0 : (exceptionTableAddr + 4);
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000802 break;
803 case 1:
804 personalityRoutine = (unw_word_t) &__aeabi_unwind_cpp_pr1;
805 extraWords = (exceptionTableData & 0x00ff0000) >> 16;
806 scope32 = false;
Logan Chiena54f0962015-05-29 15:33:38 +0000807 lsda = exceptionTableAddr + (extraWords + 1) * 4;
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000808 break;
809 case 2:
810 personalityRoutine = (unw_word_t) &__aeabi_unwind_cpp_pr2;
811 extraWords = (exceptionTableData & 0x00ff0000) >> 16;
812 scope32 = true;
Logan Chiena54f0962015-05-29 15:33:38 +0000813 lsda = exceptionTableAddr + (extraWords + 1) * 4;
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000814 break;
815 default:
816 _LIBUNWIND_ABORT("unknown personality routine");
817 return false;
818 }
819
820 if (isSingleWordEHT) {
821 if (extraWords != 0) {
822 _LIBUNWIND_ABORT("index inlined table detected but pr function "
823 "requires extra words");
824 return false;
825 }
826 }
827 } else {
828 pint_t personalityAddr =
829 exceptionTableAddr + signExtendPrel31(exceptionTableData);
830 personalityRoutine = personalityAddr;
831
832 // ARM EHABI # 6.2, # 9.2
833 //
834 // +---- ehtp
835 // v
836 // +--------------------------------------+
837 // | +--------+--------+--------+-------+ |
838 // | |0| prel31 to personalityRoutine | |
839 // | +--------+--------+--------+-------+ |
840 // | | N | unwind opcodes | | <-- UnwindData
841 // | +--------+--------+--------+-------+ |
842 // | | Word 2 unwind opcodes | |
843 // | +--------+--------+--------+-------+ |
844 // | ... |
845 // | +--------+--------+--------+-------+ |
846 // | | Word N unwind opcodes | |
847 // | +--------+--------+--------+-------+ |
848 // | | LSDA | | <-- lsda
849 // | | ... | |
850 // | +--------+--------+--------+-------+ |
851 // +--------------------------------------+
852
853 uint32_t *UnwindData = reinterpret_cast<uint32_t*>(exceptionTableAddr) + 1;
854 uint32_t FirstDataWord = *UnwindData;
855 size_t N = ((FirstDataWord >> 24) & 0xff);
856 size_t NDataWords = N + 1;
857 lsda = reinterpret_cast<uintptr_t>(UnwindData + NDataWords);
858 }
859
860 _info.start_ip = thisPC;
861 _info.end_ip = nextPC;
862 _info.handler = personalityRoutine;
863 _info.unwind_info = exceptionTableAddr;
864 _info.lsda = lsda;
865 // flags is pr_cache.additional. See EHABI #7.2 for definition of bit 0.
866 _info.flags = isSingleWordEHT ? 1 : 0 | scope32 ? 0x2 : 0; // Use enum?
867
868 return true;
869}
870#endif
871
Ranjeet Singh421231a2017-03-31 15:28:06 +0000872#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000873template <typename A, typename R>
874bool UnwindCursor<A, R>::getInfoFromDwarfSection(pint_t pc,
875 const UnwindInfoSections &sects,
876 uint32_t fdeSectionOffsetHint) {
877 typename CFI_Parser<A>::FDE_Info fdeInfo;
878 typename CFI_Parser<A>::CIE_Info cieInfo;
879 bool foundFDE = false;
880 bool foundInCache = false;
881 // If compact encoding table gave offset into dwarf section, go directly there
882 if (fdeSectionOffsetHint != 0) {
883 foundFDE = CFI_Parser<A>::findFDE(_addressSpace, pc, sects.dwarf_section,
884 (uint32_t)sects.dwarf_section_length,
885 sects.dwarf_section + fdeSectionOffsetHint,
886 &fdeInfo, &cieInfo);
887 }
Ranjeet Singh421231a2017-03-31 15:28:06 +0000888#if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000889 if (!foundFDE && (sects.dwarf_index_section != 0)) {
890 foundFDE = EHHeaderParser<A>::findFDE(
891 _addressSpace, pc, sects.dwarf_index_section,
892 (uint32_t)sects.dwarf_index_section_length, &fdeInfo, &cieInfo);
893 }
894#endif
895 if (!foundFDE) {
896 // otherwise, search cache of previously found FDEs.
897 pint_t cachedFDE = DwarfFDECache<A>::findFDE(sects.dso_base, pc);
898 if (cachedFDE != 0) {
899 foundFDE =
900 CFI_Parser<A>::findFDE(_addressSpace, pc, sects.dwarf_section,
901 (uint32_t)sects.dwarf_section_length,
902 cachedFDE, &fdeInfo, &cieInfo);
903 foundInCache = foundFDE;
904 }
905 }
906 if (!foundFDE) {
907 // Still not found, do full scan of __eh_frame section.
908 foundFDE = CFI_Parser<A>::findFDE(_addressSpace, pc, sects.dwarf_section,
909 (uint32_t)sects.dwarf_section_length, 0,
910 &fdeInfo, &cieInfo);
911 }
912 if (foundFDE) {
913 typename CFI_Parser<A>::PrologInfo prolog;
914 if (CFI_Parser<A>::parseFDEInstructions(_addressSpace, fdeInfo, cieInfo, pc,
915 &prolog)) {
916 // Save off parsed FDE info
917 _info.start_ip = fdeInfo.pcStart;
918 _info.end_ip = fdeInfo.pcEnd;
919 _info.lsda = fdeInfo.lsda;
920 _info.handler = cieInfo.personality;
921 _info.gp = prolog.spExtraArgSize;
922 _info.flags = 0;
923 _info.format = dwarfEncoding();
924 _info.unwind_info = fdeInfo.fdeStart;
925 _info.unwind_info_size = (uint32_t)fdeInfo.fdeLength;
926 _info.extra = (unw_word_t) sects.dso_base;
927
928 // Add to cache (to make next lookup faster) if we had no hint
929 // and there was no index.
930 if (!foundInCache && (fdeSectionOffsetHint == 0)) {
Ranjeet Singh421231a2017-03-31 15:28:06 +0000931 #if defined(_LIBUNWIND_SUPPORT_DWARF_INDEX)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000932 if (sects.dwarf_index_section == 0)
933 #endif
934 DwarfFDECache<A>::add(sects.dso_base, fdeInfo.pcStart, fdeInfo.pcEnd,
935 fdeInfo.fdeStart);
936 }
937 return true;
938 }
939 }
Ed Maste41bc5a72016-08-30 15:38:10 +0000940 //_LIBUNWIND_DEBUG_LOG("can't find/use FDE for pc=0x%llX", (uint64_t)pc);
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000941 return false;
942}
Ranjeet Singh421231a2017-03-31 15:28:06 +0000943#endif // defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000944
945
Ranjeet Singh421231a2017-03-31 15:28:06 +0000946#if defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +0000947template <typename A, typename R>
948bool UnwindCursor<A, R>::getInfoFromCompactEncodingSection(pint_t pc,
949 const UnwindInfoSections &sects) {
950 const bool log = false;
951 if (log)
952 fprintf(stderr, "getInfoFromCompactEncodingSection(pc=0x%llX, mh=0x%llX)\n",
953 (uint64_t)pc, (uint64_t)sects.dso_base);
954
955 const UnwindSectionHeader<A> sectionHeader(_addressSpace,
956 sects.compact_unwind_section);
957 if (sectionHeader.version() != UNWIND_SECTION_VERSION)
958 return false;
959
960 // do a binary search of top level index to find page with unwind info
961 pint_t targetFunctionOffset = pc - sects.dso_base;
962 const UnwindSectionIndexArray<A> topIndex(_addressSpace,
963 sects.compact_unwind_section
964 + sectionHeader.indexSectionOffset());
965 uint32_t low = 0;
966 uint32_t high = sectionHeader.indexCount();
967 uint32_t last = high - 1;
968 while (low < high) {
969 uint32_t mid = (low + high) / 2;
970 //if ( log ) fprintf(stderr, "\tmid=%d, low=%d, high=%d, *mid=0x%08X\n",
971 //mid, low, high, topIndex.functionOffset(mid));
972 if (topIndex.functionOffset(mid) <= targetFunctionOffset) {
973 if ((mid == last) ||
974 (topIndex.functionOffset(mid + 1) > targetFunctionOffset)) {
975 low = mid;
976 break;
977 } else {
978 low = mid + 1;
979 }
980 } else {
981 high = mid;
982 }
983 }
984 const uint32_t firstLevelFunctionOffset = topIndex.functionOffset(low);
985 const uint32_t firstLevelNextPageFunctionOffset =
986 topIndex.functionOffset(low + 1);
987 const pint_t secondLevelAddr =
988 sects.compact_unwind_section + topIndex.secondLevelPagesSectionOffset(low);
989 const pint_t lsdaArrayStartAddr =
990 sects.compact_unwind_section + topIndex.lsdaIndexArraySectionOffset(low);
991 const pint_t lsdaArrayEndAddr =
992 sects.compact_unwind_section + topIndex.lsdaIndexArraySectionOffset(low+1);
993 if (log)
994 fprintf(stderr, "\tfirst level search for result index=%d "
995 "to secondLevelAddr=0x%llX\n",
996 low, (uint64_t) secondLevelAddr);
997 // do a binary search of second level page index
998 uint32_t encoding = 0;
999 pint_t funcStart = 0;
1000 pint_t funcEnd = 0;
1001 pint_t lsda = 0;
1002 pint_t personality = 0;
1003 uint32_t pageKind = _addressSpace.get32(secondLevelAddr);
1004 if (pageKind == UNWIND_SECOND_LEVEL_REGULAR) {
1005 // regular page
1006 UnwindSectionRegularPageHeader<A> pageHeader(_addressSpace,
1007 secondLevelAddr);
1008 UnwindSectionRegularArray<A> pageIndex(
1009 _addressSpace, secondLevelAddr + pageHeader.entryPageOffset());
1010 // binary search looks for entry with e where index[e].offset <= pc <
1011 // index[e+1].offset
1012 if (log)
1013 fprintf(stderr, "\tbinary search for targetFunctionOffset=0x%08llX in "
1014 "regular page starting at secondLevelAddr=0x%llX\n",
1015 (uint64_t) targetFunctionOffset, (uint64_t) secondLevelAddr);
1016 low = 0;
1017 high = pageHeader.entryCount();
1018 while (low < high) {
1019 uint32_t mid = (low + high) / 2;
1020 if (pageIndex.functionOffset(mid) <= targetFunctionOffset) {
1021 if (mid == (uint32_t)(pageHeader.entryCount() - 1)) {
1022 // at end of table
1023 low = mid;
1024 funcEnd = firstLevelNextPageFunctionOffset + sects.dso_base;
1025 break;
1026 } else if (pageIndex.functionOffset(mid + 1) > targetFunctionOffset) {
1027 // next is too big, so we found it
1028 low = mid;
1029 funcEnd = pageIndex.functionOffset(low + 1) + sects.dso_base;
1030 break;
1031 } else {
1032 low = mid + 1;
1033 }
1034 } else {
1035 high = mid;
1036 }
1037 }
1038 encoding = pageIndex.encoding(low);
1039 funcStart = pageIndex.functionOffset(low) + sects.dso_base;
1040 if (pc < funcStart) {
1041 if (log)
1042 fprintf(
1043 stderr,
1044 "\tpc not in table, pc=0x%llX, funcStart=0x%llX, funcEnd=0x%llX\n",
1045 (uint64_t) pc, (uint64_t) funcStart, (uint64_t) funcEnd);
1046 return false;
1047 }
1048 if (pc > funcEnd) {
1049 if (log)
1050 fprintf(
1051 stderr,
1052 "\tpc not in table, pc=0x%llX, funcStart=0x%llX, funcEnd=0x%llX\n",
1053 (uint64_t) pc, (uint64_t) funcStart, (uint64_t) funcEnd);
1054 return false;
1055 }
1056 } else if (pageKind == UNWIND_SECOND_LEVEL_COMPRESSED) {
1057 // compressed page
1058 UnwindSectionCompressedPageHeader<A> pageHeader(_addressSpace,
1059 secondLevelAddr);
1060 UnwindSectionCompressedArray<A> pageIndex(
1061 _addressSpace, secondLevelAddr + pageHeader.entryPageOffset());
1062 const uint32_t targetFunctionPageOffset =
1063 (uint32_t)(targetFunctionOffset - firstLevelFunctionOffset);
1064 // binary search looks for entry with e where index[e].offset <= pc <
1065 // index[e+1].offset
1066 if (log)
1067 fprintf(stderr, "\tbinary search of compressed page starting at "
1068 "secondLevelAddr=0x%llX\n",
1069 (uint64_t) secondLevelAddr);
1070 low = 0;
1071 last = pageHeader.entryCount() - 1;
1072 high = pageHeader.entryCount();
1073 while (low < high) {
1074 uint32_t mid = (low + high) / 2;
1075 if (pageIndex.functionOffset(mid) <= targetFunctionPageOffset) {
1076 if ((mid == last) ||
1077 (pageIndex.functionOffset(mid + 1) > targetFunctionPageOffset)) {
1078 low = mid;
1079 break;
1080 } else {
1081 low = mid + 1;
1082 }
1083 } else {
1084 high = mid;
1085 }
1086 }
1087 funcStart = pageIndex.functionOffset(low) + firstLevelFunctionOffset
1088 + sects.dso_base;
1089 if (low < last)
1090 funcEnd =
1091 pageIndex.functionOffset(low + 1) + firstLevelFunctionOffset
1092 + sects.dso_base;
1093 else
1094 funcEnd = firstLevelNextPageFunctionOffset + sects.dso_base;
1095 if (pc < funcStart) {
1096 _LIBUNWIND_DEBUG_LOG("malformed __unwind_info, pc=0x%llX not in second "
Ed Maste41bc5a72016-08-30 15:38:10 +00001097 "level compressed unwind table. funcStart=0x%llX",
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001098 (uint64_t) pc, (uint64_t) funcStart);
1099 return false;
1100 }
1101 if (pc > funcEnd) {
1102 _LIBUNWIND_DEBUG_LOG("malformed __unwind_info, pc=0x%llX not in second "
Ed Maste41bc5a72016-08-30 15:38:10 +00001103 "level compressed unwind table. funcEnd=0x%llX",
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001104 (uint64_t) pc, (uint64_t) funcEnd);
1105 return false;
1106 }
1107 uint16_t encodingIndex = pageIndex.encodingIndex(low);
1108 if (encodingIndex < sectionHeader.commonEncodingsArrayCount()) {
1109 // encoding is in common table in section header
1110 encoding = _addressSpace.get32(
1111 sects.compact_unwind_section +
1112 sectionHeader.commonEncodingsArraySectionOffset() +
1113 encodingIndex * sizeof(uint32_t));
1114 } else {
1115 // encoding is in page specific table
1116 uint16_t pageEncodingIndex =
1117 encodingIndex - (uint16_t)sectionHeader.commonEncodingsArrayCount();
1118 encoding = _addressSpace.get32(secondLevelAddr +
1119 pageHeader.encodingsPageOffset() +
1120 pageEncodingIndex * sizeof(uint32_t));
1121 }
1122 } else {
1123 _LIBUNWIND_DEBUG_LOG("malformed __unwind_info at 0x%0llX bad second "
Ed Maste41bc5a72016-08-30 15:38:10 +00001124 "level page",
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001125 (uint64_t) sects.compact_unwind_section);
1126 return false;
1127 }
1128
1129 // look up LSDA, if encoding says function has one
1130 if (encoding & UNWIND_HAS_LSDA) {
1131 UnwindSectionLsdaArray<A> lsdaIndex(_addressSpace, lsdaArrayStartAddr);
1132 uint32_t funcStartOffset = (uint32_t)(funcStart - sects.dso_base);
1133 low = 0;
1134 high = (uint32_t)(lsdaArrayEndAddr - lsdaArrayStartAddr) /
1135 sizeof(unwind_info_section_header_lsda_index_entry);
1136 // binary search looks for entry with exact match for functionOffset
1137 if (log)
1138 fprintf(stderr,
1139 "\tbinary search of lsda table for targetFunctionOffset=0x%08X\n",
1140 funcStartOffset);
1141 while (low < high) {
1142 uint32_t mid = (low + high) / 2;
1143 if (lsdaIndex.functionOffset(mid) == funcStartOffset) {
1144 lsda = lsdaIndex.lsdaOffset(mid) + sects.dso_base;
1145 break;
1146 } else if (lsdaIndex.functionOffset(mid) < funcStartOffset) {
1147 low = mid + 1;
1148 } else {
1149 high = mid;
1150 }
1151 }
1152 if (lsda == 0) {
1153 _LIBUNWIND_DEBUG_LOG("found encoding 0x%08X with HAS_LSDA bit set for "
Ed Maste41bc5a72016-08-30 15:38:10 +00001154 "pc=0x%0llX, but lsda table has no entry",
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001155 encoding, (uint64_t) pc);
1156 return false;
1157 }
1158 }
1159
1160 // extact personality routine, if encoding says function has one
1161 uint32_t personalityIndex = (encoding & UNWIND_PERSONALITY_MASK) >>
1162 (__builtin_ctz(UNWIND_PERSONALITY_MASK));
1163 if (personalityIndex != 0) {
1164 --personalityIndex; // change 1-based to zero-based index
1165 if (personalityIndex > sectionHeader.personalityArrayCount()) {
1166 _LIBUNWIND_DEBUG_LOG("found encoding 0x%08X with personality index %d, "
Ed Maste41bc5a72016-08-30 15:38:10 +00001167 "but personality table has only %d entires",
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001168 encoding, personalityIndex,
1169 sectionHeader.personalityArrayCount());
1170 return false;
1171 }
1172 int32_t personalityDelta = (int32_t)_addressSpace.get32(
1173 sects.compact_unwind_section +
1174 sectionHeader.personalityArraySectionOffset() +
1175 personalityIndex * sizeof(uint32_t));
1176 pint_t personalityPointer = sects.dso_base + (pint_t)personalityDelta;
1177 personality = _addressSpace.getP(personalityPointer);
1178 if (log)
1179 fprintf(stderr, "getInfoFromCompactEncodingSection(pc=0x%llX), "
1180 "personalityDelta=0x%08X, personality=0x%08llX\n",
1181 (uint64_t) pc, personalityDelta, (uint64_t) personality);
1182 }
1183
1184 if (log)
1185 fprintf(stderr, "getInfoFromCompactEncodingSection(pc=0x%llX), "
1186 "encoding=0x%08X, lsda=0x%08llX for funcStart=0x%llX\n",
1187 (uint64_t) pc, encoding, (uint64_t) lsda, (uint64_t) funcStart);
1188 _info.start_ip = funcStart;
1189 _info.end_ip = funcEnd;
1190 _info.lsda = lsda;
1191 _info.handler = personality;
1192 _info.gp = 0;
1193 _info.flags = 0;
1194 _info.format = encoding;
1195 _info.unwind_info = 0;
1196 _info.unwind_info_size = 0;
1197 _info.extra = sects.dso_base;
1198 return true;
1199}
Ranjeet Singh421231a2017-03-31 15:28:06 +00001200#endif // defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001201
1202
1203template <typename A, typename R>
1204void UnwindCursor<A, R>::setInfoBasedOnIPRegister(bool isReturnAddress) {
1205 pint_t pc = (pint_t)this->getReg(UNW_REG_IP);
Ranjeet Singh421231a2017-03-31 15:28:06 +00001206#if defined(_LIBUNWIND_ARM_EHABI)
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001207 // Remove the thumb bit so the IP represents the actual instruction address.
1208 // This matches the behaviour of _Unwind_GetIP on arm.
1209 pc &= (pint_t)~0x1;
1210#endif
1211
1212 // If the last line of a function is a "throw" the compiler sometimes
1213 // emits no instructions after the call to __cxa_throw. This means
1214 // the return address is actually the start of the next function.
1215 // To disambiguate this, back up the pc when we know it is a return
1216 // address.
1217 if (isReturnAddress)
1218 --pc;
1219
1220 // Ask address space object to find unwind sections for this pc.
1221 UnwindInfoSections sects;
1222 if (_addressSpace.findUnwindSections(pc, sects)) {
Ranjeet Singh421231a2017-03-31 15:28:06 +00001223#if defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001224 // If there is a compact unwind encoding table, look there first.
1225 if (sects.compact_unwind_section != 0) {
1226 if (this->getInfoFromCompactEncodingSection(pc, sects)) {
Ranjeet Singh421231a2017-03-31 15:28:06 +00001227 #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001228 // Found info in table, done unless encoding says to use dwarf.
1229 uint32_t dwarfOffset;
1230 if ((sects.dwarf_section != 0) && compactSaysUseDwarf(&dwarfOffset)) {
1231 if (this->getInfoFromDwarfSection(pc, sects, dwarfOffset)) {
1232 // found info in dwarf, done
1233 return;
1234 }
1235 }
1236 #endif
1237 // If unwind table has entry, but entry says there is no unwind info,
1238 // record that we have no unwind info.
1239 if (_info.format == 0)
1240 _unwindInfoMissing = true;
1241 return;
1242 }
1243 }
Ranjeet Singh421231a2017-03-31 15:28:06 +00001244#endif // defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001245
Ranjeet Singh421231a2017-03-31 15:28:06 +00001246#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001247 // If there is dwarf unwind info, look there next.
1248 if (sects.dwarf_section != 0) {
1249 if (this->getInfoFromDwarfSection(pc, sects)) {
1250 // found info in dwarf, done
1251 return;
1252 }
1253 }
1254#endif
1255
Ranjeet Singh421231a2017-03-31 15:28:06 +00001256#if defined(_LIBUNWIND_ARM_EHABI)
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001257 // If there is ARM EHABI unwind info, look there next.
1258 if (sects.arm_section != 0 && this->getInfoFromEHABISection(pc, sects))
1259 return;
1260#endif
1261 }
1262
Ranjeet Singh421231a2017-03-31 15:28:06 +00001263#if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001264 // There is no static unwind info for this pc. Look to see if an FDE was
1265 // dynamically registered for it.
1266 pint_t cachedFDE = DwarfFDECache<A>::findFDE(0, pc);
1267 if (cachedFDE != 0) {
1268 CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo;
1269 CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo;
1270 const char *msg = CFI_Parser<A>::decodeFDE(_addressSpace,
1271 cachedFDE, &fdeInfo, &cieInfo);
1272 if (msg == NULL) {
1273 typename CFI_Parser<A>::PrologInfo prolog;
1274 if (CFI_Parser<A>::parseFDEInstructions(_addressSpace, fdeInfo, cieInfo,
1275 pc, &prolog)) {
1276 // save off parsed FDE info
1277 _info.start_ip = fdeInfo.pcStart;
1278 _info.end_ip = fdeInfo.pcEnd;
1279 _info.lsda = fdeInfo.lsda;
1280 _info.handler = cieInfo.personality;
1281 _info.gp = prolog.spExtraArgSize;
1282 // Some frameless functions need SP
1283 // altered when resuming in function.
1284 _info.flags = 0;
1285 _info.format = dwarfEncoding();
1286 _info.unwind_info = fdeInfo.fdeStart;
1287 _info.unwind_info_size = (uint32_t)fdeInfo.fdeLength;
1288 _info.extra = 0;
1289 return;
1290 }
1291 }
1292 }
1293
1294 // Lastly, ask AddressSpace object about platform specific ways to locate
1295 // other FDEs.
1296 pint_t fde;
1297 if (_addressSpace.findOtherFDE(pc, fde)) {
1298 CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo;
1299 CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo;
1300 if (!CFI_Parser<A>::decodeFDE(_addressSpace, fde, &fdeInfo, &cieInfo)) {
1301 // Double check this FDE is for a function that includes the pc.
1302 if ((fdeInfo.pcStart <= pc) && (pc < fdeInfo.pcEnd)) {
1303 typename CFI_Parser<A>::PrologInfo prolog;
1304 if (CFI_Parser<A>::parseFDEInstructions(_addressSpace, fdeInfo,
1305 cieInfo, pc, &prolog)) {
1306 // save off parsed FDE info
1307 _info.start_ip = fdeInfo.pcStart;
1308 _info.end_ip = fdeInfo.pcEnd;
1309 _info.lsda = fdeInfo.lsda;
1310 _info.handler = cieInfo.personality;
1311 _info.gp = prolog.spExtraArgSize;
1312 _info.flags = 0;
1313 _info.format = dwarfEncoding();
1314 _info.unwind_info = fdeInfo.fdeStart;
1315 _info.unwind_info_size = (uint32_t)fdeInfo.fdeLength;
1316 _info.extra = 0;
1317 return;
1318 }
1319 }
1320 }
1321 }
Ranjeet Singh421231a2017-03-31 15:28:06 +00001322#endif // #if defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001323
1324 // no unwind info, flag that we can't reliably unwind
1325 _unwindInfoMissing = true;
1326}
1327
1328template <typename A, typename R>
1329int UnwindCursor<A, R>::step() {
1330 // Bottom of stack is defined is when unwind info cannot be found.
1331 if (_unwindInfoMissing)
1332 return UNW_STEP_END;
1333
1334 // Use unwinding info to modify register set as if function returned.
1335 int result;
Ranjeet Singh421231a2017-03-31 15:28:06 +00001336#if defined(_LIBUNWIND_SUPPORT_COMPACT_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001337 result = this->stepWithCompactEncoding();
Ranjeet Singh421231a2017-03-31 15:28:06 +00001338#elif defined(_LIBUNWIND_SUPPORT_DWARF_UNWIND)
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001339 result = this->stepWithDwarfFDE();
Ranjeet Singh421231a2017-03-31 15:28:06 +00001340#elif defined(_LIBUNWIND_ARM_EHABI)
Logan Chiena54f0962015-05-29 15:33:38 +00001341 result = this->stepWithEHABI();
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001342#else
1343 #error Need _LIBUNWIND_SUPPORT_COMPACT_UNWIND or \
1344 _LIBUNWIND_SUPPORT_DWARF_UNWIND or \
Logan Chien06b0c7a2015-07-19 15:23:10 +00001345 _LIBUNWIND_ARM_EHABI
Saleem Abdulrasool17552662015-04-24 19:39:17 +00001346#endif
1347
1348 // update info based on new PC
1349 if (result == UNW_STEP_SUCCESS) {
1350 this->setInfoBasedOnIPRegister(true);
1351 if (_unwindInfoMissing)
1352 return UNW_STEP_END;
1353 if (_info.gp)
1354 setReg(UNW_REG_SP, getReg(UNW_REG_SP) + _info.gp);
1355 }
1356
1357 return result;
1358}
1359
1360template <typename A, typename R>
1361void UnwindCursor<A, R>::getInfo(unw_proc_info_t *info) {
1362 *info = _info;
1363}
1364
1365template <typename A, typename R>
1366bool UnwindCursor<A, R>::getFunctionName(char *buf, size_t bufLen,
1367 unw_word_t *offset) {
1368 return _addressSpace.findFunctionName((pint_t)this->getReg(UNW_REG_IP),
1369 buf, bufLen, offset);
1370}
1371
1372} // namespace libunwind
1373
1374#endif // __UNWINDCURSOR_HPP__