1//===--------------------------- libuwind.cpp -----------------------------===//
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//  Implements unw_* functions from <libunwind.h>
10//
11//===----------------------------------------------------------------------===//
12
13#include <libunwind.h>
14
15#ifndef NDEBUG
16#include <cstdlib> // getenv
17#endif
18#include <new>
19
20#include "libunwind_ext.h"
21#include "config.h"
22
23#include <stdlib.h>
24
25
26#if _LIBUNWIND_BUILD_ZERO_COST_APIS
27
28#include "UnwindCursor.hpp"
29
30using namespace libunwind;
31
32/// internal object to represent this processes address space
33LocalAddressSpace LocalAddressSpace::sThisAddressSpace;
34
35/// record the registers and stack position of the caller
36extern int unw_getcontext(unw_context_t *);
37// note: unw_getcontext() implemented in assembly
38
39/// Create a cursor of a thread in this process given 'context' recorded by
40/// unw_getcontext().
41_LIBUNWIND_EXPORT int unw_init_local(unw_cursor_t *cursor,
42                                     unw_context_t *context) {
43  _LIBUNWIND_TRACE_API("unw_init_local(cursor=%p, context=%p)\n",
44                              cursor, context);
45  // Use "placement new" to allocate UnwindCursor in the cursor buffer.
46#if __i386__
47  new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_x86>(
48                                 context, LocalAddressSpace::sThisAddressSpace);
49#elif __x86_64__
50  new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_x86_64>(
51                                 context, LocalAddressSpace::sThisAddressSpace);
52#elif __ppc__
53  new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_ppc>(
54                                 context, LocalAddressSpace::sThisAddressSpace);
55#elif __arm64__
56  new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_arm64>(
57                                 context, LocalAddressSpace::sThisAddressSpace);
58#elif LIBCXXABI_ARM_EHABI
59  new ((void *)cursor) UnwindCursor<LocalAddressSpace, Registers_arm>(
60                                 context, LocalAddressSpace::sThisAddressSpace);
61#endif
62  AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
63  co->setInfoBasedOnIPRegister();
64
65  return UNW_ESUCCESS;
66}
67
68#if UNW_REMOTE
69
70_LIBUNWIND_EXPORT unw_addr_space_t unw_local_addr_space =
71    (unw_addr_space_t) & sThisAddressSpace;
72
73/// Create a cursor into a thread in another process.
74_LIBUNWIND_EXPORT int unw_init_remote_thread(unw_cursor_t *cursor,
75                                             unw_addr_space_t as,
76                                             void *arg) {
77  // special case: unw_init_remote(xx, unw_local_addr_space, xx)
78  if (as == (unw_addr_space_t) & sThisAddressSpace)
79    return unw_init_local(cursor, NULL); //FIXME
80
81  // use "placement new" to allocate UnwindCursor in the cursor buffer
82  switch (as->cpuType) {
83  case CPU_TYPE_I386:
84    new ((void *)cursor)
85        UnwindCursor<OtherAddressSpace<Pointer32<LittleEndian> >,
86                     Registers_x86>(((unw_addr_space_i386 *)as)->oas, arg);
87    break;
88  case CPU_TYPE_X86_64:
89    new ((void *)cursor) UnwindCursor<
90        OtherAddressSpace<Pointer64<LittleEndian> >, Registers_x86_64>(
91        ((unw_addr_space_x86_64 *)as)->oas, arg);
92    break;
93  case CPU_TYPE_POWERPC:
94    new ((void *)cursor)
95        UnwindCursor<OtherAddressSpace<Pointer32<BigEndian> >, Registers_ppc>(
96            ((unw_addr_space_ppc *)as)->oas, arg);
97    break;
98  default:
99    return UNW_EUNSPEC;
100  }
101  return UNW_ESUCCESS;
102}
103
104
105static bool is64bit(task_t task) {
106  return false; // FIXME
107}
108
109/// Create an address_space object for use in examining another task.
110_LIBUNWIND_EXPORT unw_addr_space_t unw_create_addr_space_for_task(task_t task) {
111#if __i386__
112  if (is64bit(task)) {
113    unw_addr_space_x86_64 *as = new unw_addr_space_x86_64(task);
114    as->taskPort = task;
115    as->cpuType = CPU_TYPE_X86_64;
116    //as->oas
117  } else {
118    unw_addr_space_i386 *as = new unw_addr_space_i386(task);
119    as->taskPort = task;
120    as->cpuType = CPU_TYPE_I386;
121    //as->oas
122  }
123#else
124// FIXME
125#endif
126}
127
128
129/// Delete an address_space object.
130_LIBUNWIND_EXPORT void unw_destroy_addr_space(unw_addr_space_t asp) {
131  switch (asp->cpuType) {
132#if __i386__ || __x86_64__
133  case CPU_TYPE_I386: {
134    unw_addr_space_i386 *as = (unw_addr_space_i386 *)asp;
135    delete as;
136  }
137  break;
138  case CPU_TYPE_X86_64: {
139    unw_addr_space_x86_64 *as = (unw_addr_space_x86_64 *)asp;
140    delete as;
141  }
142  break;
143#endif
144  case CPU_TYPE_POWERPC: {
145    unw_addr_space_ppc *as = (unw_addr_space_ppc *)asp;
146    delete as;
147  }
148  break;
149  }
150}
151#endif // UNW_REMOTE
152
153
154/// Get value of specified register at cursor position in stack frame.
155_LIBUNWIND_EXPORT int unw_get_reg(unw_cursor_t *cursor, unw_regnum_t regNum,
156                                  unw_word_t *value) {
157  _LIBUNWIND_TRACE_API("unw_get_reg(cursor=%p, regNum=%d, &value=%p)\n",
158                              cursor, regNum, value);
159  AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
160  if (co->validReg(regNum)) {
161    *value = co->getReg(regNum);
162    return UNW_ESUCCESS;
163  }
164  return UNW_EBADREG;
165}
166
167
168/// Set value of specified register at cursor position in stack frame.
169_LIBUNWIND_EXPORT int unw_set_reg(unw_cursor_t *cursor, unw_regnum_t regNum,
170                                  unw_word_t value) {
171  _LIBUNWIND_TRACE_API("unw_set_reg(cursor=%p, regNum=%d, value=0x%llX)\n",
172                       cursor, regNum, (long long)value);
173  typedef LocalAddressSpace::pint_t pint_t;
174  AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
175  if (co->validReg(regNum)) {
176    co->setReg(regNum, (pint_t)value);
177    // specical case altering IP to re-find info (being called by personality
178    // function)
179    if (regNum == UNW_REG_IP)
180      co->setInfoBasedOnIPRegister(false);
181    return UNW_ESUCCESS;
182  }
183  return UNW_EBADREG;
184}
185
186
187/// Get value of specified float register at cursor position in stack frame.
188_LIBUNWIND_EXPORT int unw_get_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum,
189                                    unw_fpreg_t *value) {
190  _LIBUNWIND_TRACE_API("unw_get_fpreg(cursor=%p, regNum=%d, &value=%p)\n",
191                             cursor, regNum, value);
192  AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
193  if (co->validFloatReg(regNum)) {
194    *value = co->getFloatReg(regNum);
195    return UNW_ESUCCESS;
196  }
197  return UNW_EBADREG;
198}
199
200
201/// Set value of specified float register at cursor position in stack frame.
202_LIBUNWIND_EXPORT int unw_set_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum,
203                                    unw_fpreg_t value) {
204#if LIBCXXABI_ARM_EHABI
205  _LIBUNWIND_TRACE_API("unw_set_fpreg(cursor=%p, regNum=%d, value=%llX)\n",
206                       cursor, regNum, value);
207#else
208  _LIBUNWIND_TRACE_API("unw_set_fpreg(cursor=%p, regNum=%d, value=%g)\n",
209                       cursor, regNum, value);
210#endif
211  AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
212  if (co->validFloatReg(regNum)) {
213    co->setFloatReg(regNum, value);
214    return UNW_ESUCCESS;
215  }
216  return UNW_EBADREG;
217}
218
219
220/// Move cursor to next frame.
221_LIBUNWIND_EXPORT int unw_step(unw_cursor_t *cursor) {
222  _LIBUNWIND_TRACE_API("unw_step(cursor=%p)\n", cursor);
223  AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
224  return co->step();
225}
226
227
228/// Get unwind info at cursor position in stack frame.
229_LIBUNWIND_EXPORT int unw_get_proc_info(unw_cursor_t *cursor,
230                                        unw_proc_info_t *info) {
231  _LIBUNWIND_TRACE_API("unw_get_proc_info(cursor=%p, &info=%p)\n",
232                             cursor, info);
233  AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
234  co->getInfo(info);
235  if (info->end_ip == 0)
236    return UNW_ENOINFO;
237  else
238    return UNW_ESUCCESS;
239}
240
241
242/// Resume execution at cursor position (aka longjump).
243_LIBUNWIND_EXPORT int unw_resume(unw_cursor_t *cursor) {
244  _LIBUNWIND_TRACE_API("unw_resume(cursor=%p)\n", cursor);
245  AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
246  co->jumpto();
247  return UNW_EUNSPEC;
248}
249
250
251/// Get name of function at cursor position in stack frame.
252_LIBUNWIND_EXPORT int unw_get_proc_name(unw_cursor_t *cursor, char *buf,
253                                        size_t bufLen, unw_word_t *offset) {
254  _LIBUNWIND_TRACE_API("unw_get_proc_name(cursor=%p, &buf=%p,"
255                             "bufLen=%zu)\n", cursor, buf, bufLen);
256  AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
257  if (co->getFunctionName(buf, bufLen, offset))
258    return UNW_ESUCCESS;
259  else
260    return UNW_EUNSPEC;
261}
262
263
264/// Checks if a register is a floating-point register.
265_LIBUNWIND_EXPORT int unw_is_fpreg(unw_cursor_t *cursor, unw_regnum_t regNum) {
266  _LIBUNWIND_TRACE_API("unw_is_fpreg(cursor=%p, regNum=%d)\n",
267                             cursor, regNum);
268  AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
269  return co->validFloatReg(regNum);
270}
271
272
273/// Checks if a register is a floating-point register.
274_LIBUNWIND_EXPORT const char *unw_regname(unw_cursor_t *cursor,
275                                          unw_regnum_t regNum) {
276  _LIBUNWIND_TRACE_API("unw_regname(cursor=%p, regNum=%d)\n",
277                             cursor, regNum);
278  AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
279  return co->getRegisterName(regNum);
280}
281
282
283/// Checks if current frame is signal trampoline.
284_LIBUNWIND_EXPORT int unw_is_signal_frame(unw_cursor_t *cursor) {
285  _LIBUNWIND_TRACE_API("unw_is_signal_frame(cursor=%p)\n", cursor);
286  AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
287  return co->isSignalFrame();
288}
289
290#if __arm__
291// Save VFP registers d0-d15 using FSTMIADX instead of FSTMIADD
292_LIBUNWIND_EXPORT void unw_save_vfp_as_X(unw_cursor_t *cursor) {
293  _LIBUNWIND_TRACE_API("unw_fpreg_save_vfp_as_X(cursor=%p)\n", cursor);
294  AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
295  return co->saveVFPAsX();
296}
297#endif
298
299
300#if _LIBUNWIND_SUPPORT_DWARF_UNWIND
301/// SPI: walks cached dwarf entries
302_LIBUNWIND_EXPORT void unw_iterate_dwarf_unwind_cache(void (*func)(
303    unw_word_t ip_start, unw_word_t ip_end, unw_word_t fde, unw_word_t mh)) {
304  _LIBUNWIND_TRACE_API("unw_iterate_dwarf_unwind_cache(func=%p)\n", func);
305  DwarfFDECache<LocalAddressSpace>::iterateCacheEntries(func);
306}
307
308
309/// IPI: for __register_frame()
310void _unw_add_dynamic_fde(unw_word_t fde) {
311  CFI_Parser<LocalAddressSpace>::FDE_Info fdeInfo;
312  CFI_Parser<LocalAddressSpace>::CIE_Info cieInfo;
313  const char *message = CFI_Parser<LocalAddressSpace>::decodeFDE(
314                           LocalAddressSpace::sThisAddressSpace,
315                          (LocalAddressSpace::pint_t) fde, &fdeInfo, &cieInfo);
316  if (message == NULL) {
317    // dynamically registered FDEs don't have a mach_header group they are in.
318    // Use fde as mh_group
319    unw_word_t mh_group = fdeInfo.fdeStart;
320    DwarfFDECache<LocalAddressSpace>::add((LocalAddressSpace::pint_t)mh_group,
321                                          fdeInfo.pcStart, fdeInfo.pcEnd,
322                                          fdeInfo.fdeStart);
323  } else {
324    _LIBUNWIND_DEBUG_LOG("_unw_add_dynamic_fde: bad fde: %s", message);
325  }
326}
327
328/// IPI: for __deregister_frame()
329void _unw_remove_dynamic_fde(unw_word_t fde) {
330  // fde is own mh_group
331  DwarfFDECache<LocalAddressSpace>::removeAllIn((LocalAddressSpace::pint_t)fde);
332}
333#endif // _LIBUNWIND_SUPPORT_DWARF_UNWIND
334
335#endif // _LIBUNWIND_BUILD_ZERO_COST_APIS
336
337
338
339// Add logging hooks in Debug builds only
340#ifndef NDEBUG
341#include <stdlib.h>
342
343_LIBUNWIND_HIDDEN
344bool logAPIs() {
345  // do manual lock to avoid use of _cxa_guard_acquire or initializers
346  static bool checked = false;
347  static bool log = false;
348  if (!checked) {
349    log = (getenv("LIBUNWIND_PRINT_APIS") != NULL);
350    checked = true;
351  }
352  return log;
353}
354
355_LIBUNWIND_HIDDEN
356bool logUnwinding() {
357  // do manual lock to avoid use of _cxa_guard_acquire or initializers
358  static bool checked = false;
359  static bool log = false;
360  if (!checked) {
361    log = (getenv("LIBUNWIND_PRINT_UNWINDING") != NULL);
362    checked = true;
363  }
364  return log;
365}
366
367#endif // NDEBUG
368
369