1b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\documentclass{article} 2b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\usepackage[fancyhdr,pdf]{latex2man} 3b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 4b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\input{common.tex} 5b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 6b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\begin{document} 7b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 8972aec70ba48f64db9b635a47a497cd65489d343esiee.fr!m.delahaye\begin{Name}{3}{libunwind}{David Mosberger-Tang}{Programming Library}{Introduction to libunwind}libunwind -- a (mostly) platform-independent unwind API 9b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\end{Name} 10b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 11b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\section{Synopsis} 12b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 13b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\File{\#include $<$libunwind.h$>$}\\ 14b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 15b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 16b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{int} \Func{unw\_getcontext}(\Type{unw\_context\_t~*});\\ 17b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 18b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{int} \Func{unw\_init\_local}(\Type{unw\_cursor\_t~*}, \Type{unw\_context\_t~*});\\ 19b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 20b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{int} \Func{unw\_init\_remote}(\Type{unw\_cursor\_t~*}, \Type{unw\_addr\_space\_t}, \Type{void~*});\\ 21b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 22b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{int} \Func{unw\_step}(\Type{unw\_cursor\_t~*});\\ 23b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 24a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\Type{int} \Func{unw\_get\_reg}(\Type{unw\_cursor\_t~*}, \Type{unw\_regnum\_t}, \Type{unw\_word\_t~*});\\ 25b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 26a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\Type{int} \Func{unw\_get\_fpreg}(\Type{unw\_cursor\_t~*}, \Type{unw\_regnum\_t}, \Type{unw\_fpreg\_t~*});\\ 27b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 28a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\Type{int} \Func{unw\_set\_reg}(\Type{unw\_cursor\_t~*}, \Type{unw\_regnum\_t}, \Type{unw\_word\_t});\\ 29b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 30a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\Type{int} \Func{unw\_set\_fpreg}(\Type{unw\_cursor\_t~*}, \Type{unw\_regnum\_t}, \Type{unw\_fpreg\_t});\\ 31b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 32b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{int} \Func{unw\_resume}(\Type{unw\_cursor\_t~*});\\ 33b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 34b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 35a494d61a8688b9660eb95f97bfb1807598a46626mostang.com!davidm\Type{unw\_addr\_space\_t} \Var{unw\_local\_addr\_space};\\ 36b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 37b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{unw\_addr\_space\_t} \Func{unw\_create\_addr\_space}(\Type{unw\_accessors\_t}, \Type{int});\\ 38b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 39b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{void} \Func{unw\_destroy\_addr\_space}(\Type{unw\_addr\_space\_t});\\ 40b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 41b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{unw\_accessors\_t} \Func{unw\_get\_accessors}(\Type{unw\_addr\_space\_t});\\ 42b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 43b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{void} \Func{unw\_flush\_cache}(\Type{unw\_addr\_space\_t}, \Type{unw\_word\_t}, \Type{unw\_word\_t});\\ 44b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 45b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{int} \Func{unw\_set\_caching\_policy}(\Type{unw\_addr\_space\_t}, \Type{unw\_caching\_policy\_t});\\ 46b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 47b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 4838ec048c0d6fc9cf24323cafd89050e6582be0e0mostang.com!davidm\Type{const char *}\Func{unw\_regname}(\Type{unw\_regnum\_t});\\ 49b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 50b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{int} \Func{unw\_get\_proc\_info}(\Type{unw\_cursor\_t~*}, \Type{unw\_proc\_info\_t~*});\\ 51b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 52b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{int} \Func{unw\_get\_save\_loc}(\Type{unw\_cursor\_t~*}, \Type{int}, \Type{unw\_save\_loc\_t~*});\\ 53b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 54a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\Type{int} \Func{unw\_is\_fpreg}(\Type{unw\_regnum\_t});\\ 55b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{int} \Func{unw\_is\_signal\_frame}(\Type{unw\_cursor\_t~*});\\ 56b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 57f5892c26be52e370133ea0669762651e88ca3af2mostang.com!davidm\Type{int} \Func{unw\_get\_proc\_name}(\Type{unw\_cursor\_t~*}, \Type{char~*}, \Type{size\_t}, \Type{unw\_word\_t~*});\\ 58b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 59b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 60b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{void} \Func{\_U\_dyn\_register}(\Type{unw\_dyn\_info\_t~*});\\ 61b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 62b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Type{void} \Func{\_U\_dyn\_cancel}(\Type{unw\_dyn\_info\_t~*});\\ 63b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 64b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\section{Local Unwinding} 65b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 66b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Prog{Libunwind} is very easy to use when unwinding a stack from 67b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmwithin a running program. This is called \emph{local} unwinding. Say 68b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmyou want to unwind the stack while executing in some function 69b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Func{F}(). In this function, you would call \Func{unw\_getcontext}() 70b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmto get a snapshot of the CPU registers (machine-state). Then you 71b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidminitialize an \emph{unwind~cursor} based on this snapshot. This is 72b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmdone with a call to \Func{unw\_init\_local}(). The cursor now points 73b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmto the current frame, that is, the stack frame that corresponds to the 74b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmcurrent activation of function \Func{F}(). The unwind cursor can then 75b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmbe moved ``up'' (towards earlier stack frames) by calling 76b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Func{unw\_step}(). By repeatedly calling this routine, you can 77b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmuncover the entire call-chain that led to the activation of function 78b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Func{F}(). A positive return value from \Func{unw\_step}() indicates 79b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmthat there are more frames in the chain, zero indicates that the end 80b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmof the chain has been reached, and any negative value indicates that 81b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmsome sort of error has occurred. 82b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 83b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmWhile it is not possible to directly move the unwind cursor in the 84b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm``down'' direction (towards newer stack frames), this effect can be 854ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmachieved by making copies of an unwind cursor. For example, a program 864ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmthat sometimes has to move ``down'' by one stack frame could maintain 874ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmtwo cursor variables: ``\Var{curr}'' and ``\Var{prev}''. The former 884ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmwould be used as the current cursor and \Var{prev} would be maintained 894ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmas the ``previous frame'' cursor by copying the contents of \Var{curr} 904ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmto \Var{prev} right before calling \Func{unw\_step}(). With this 914ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmapproach, the program could move one step ``down'' simply by copying 924ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmback \Var{prev} to \Var{curr} whenever that is necessary. In the most 934ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmextreme case, a program could maintain a separate cursor for each call 944ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmframe and that way it could move up and down the callframe-chain at 954ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmwill. 96b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 97b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmGiven an unwind cursor, it is possible to read and write the CPU 984ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmregisters that were preserved for the current stack frame (as 994ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmidentified by the cursor). \Prog{Libunwind} provides several routines 1004ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmfor this purpose: \Func{unw\_get\_reg}() reads an integer (general) 1014ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmregister, \Func{unw\_get\_fpreg}() reads a floating-point register, 102b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Func{unw\_set\_reg}() writes an integer register, and 103b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Func{unw\_set\_fpreg}() writes a floating-point register. Note that, 104b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmby definition, only the \emph{preserved} machine state can be accessed 105b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmduring an unwind operation. Normally, this state consists of the 106b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\emph{callee-saved} (``preserved'') registers. However, in some 107b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmspecial circumstances (e.g., in a signal handler trampoline), even the 108b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\emph{caller-saved} (``scratch'') registers are preserved in the stack 109b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmframe and, in those cases, \Prog{libunwind} will grant access to them 110b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmas well. The exact set of registers that can be accessed via the 111b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmcursor depends, of course, on the platform. However, there are two 112b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmregisters that can be read on all platforms: the instruction pointer 113b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm(IP), sometimes also known as the ``program counter'', and the stack 114b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmpointer (SP). In \Prog{libunwind}, these registers are identified by 115b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmthe macros \Const{UNW\_REG\_IP} and \Const{UNW\_REG\_SP}, 116b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmrespectively. 117b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 118b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmBesides just moving the unwind cursor and reading/writing saved 119b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmregisters, \Prog{libunwind} also provides the ability to resume 120b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmexecution at an arbitrary stack frame. As you might guess, this is 121b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmuseful for implementing non-local gotos and the exception handling 122b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmneeded by some high-level languages such as Java. Resuming execution 123b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmwith a particular stack frame simply requires calling 124b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Func{unw\_resume}() and passing the cursor identifying the target 125b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmframe as the only argument. 126b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 127b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmNormally, \Prog{libunwind} supports both local and remote unwinding 128b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm(the latter will be explained in the next section). However, if you 129b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmtell libunwind that your program only needs local unwinding, then a 130b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmspecial implementation can be selected which may run much faster than 131b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmthe generic implementation which supports both kinds of unwinding. To 132b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmselect this optimized version, simply define the macro 133b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Const{UNW\_LOCAL\_ONLY} before including the headerfile 1344ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidm\File{$<$libunwind.h$>$}. It is perfectly OK for a single program to 135b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmemploy both local-only and generic unwinding. That is, whether or not 136b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Const{UNW\_LOCAL\_ONLY} is defined is a choice that each source-file 137b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm(compilation-unit) can make on its own. Independent of the setting(s) 138b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmof \Const{UNW\_LOCAL\_ONLY}, you'll always link the same library into 1394ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmthe program (normally \Opt{-l}\File{unwind}). Furthermore, the 1404ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmportion of \Prog{libunwind} that manages unwind-info for dynamically 1414ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmgenerated code is not affected by the setting of 1424ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidm\Const{UNW\_LOCAL\_ONLY}. 143b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 144b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmIf we put all of the above together, here is how we could use 1454ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidm\Prog{libunwind} to write a function ``\Func{show\_backtrace}()'' 1464ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmwhich prints a classic stack trace: 147b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 148b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\begin{verbatim} 149b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm#define UNW_LOCAL_ONLY 150b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm#include <libunwind.h> 151b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 152b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmvoid show_backtrace (void) { 153b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm unw_cursor_t cursor; unw_context_t uc; 154b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm unw_word_t ip, sp; 155b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 156b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm unw_getcontext(&uc); 157b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm unw_init_local(&cursor, &uc); 158b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm while (unw_step(&cursor) > 0) { 159b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm unw_get_reg(&cursor, UNW_REG_IP, &ip); 160b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm unw_get_reg(&cursor, UNW_REG_SP, &sp); 161bba579e2771e835d7bd08b978342c978f825b30f(none)!davidm printf ("ip = %lx, sp = %lx\n", (long) ip, (long) sp); 162b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm } 163b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm} 164b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\end{verbatim} 165b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 166b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 167b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\section{Remote Unwinding} 168b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 169b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Prog{Libunwind} can also be used to unwind a stack in a ``remote'' 170b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmprocess. Here, ``remote'' may mean another process on the same 171b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmmachine or even a process on a completely different machine from the 172b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmone that is running \Prog{libunwind}. Remote unwinding is typically 173b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmused by debuggers and instruction-set simulators, for example. 174b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 175b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmBefore you can unwind a remote process, you need to create a new 176b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmaddress-space object for that process. This is achieved with the 1774ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidm\Func{unw\_create\_addr\_space}() routine. The routine takes two 178b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmarguments: a pointer to a set of \emph{accessor} routines and an 179b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidminteger that specifies the byte-order of the target process. The 180b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmaccessor routines provide \Func{libunwind} with the means to 181b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmcommunicate with the remote process. In particular, there are 182b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmcallbacks to read and write the process's memory, its registers, and 183b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmto access unwind information which may be needed by \Func{libunwind}. 184b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 185b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmWith the address space created, unwinding can be initiated by a call 186b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmto \Func{unw\_init\_remote}(). This routine is very similar to 187b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Func{unw\_init\_local}(), except that it takes an address-space 188b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmobject and an opaque pointer as arguments. The routine uses these 189b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmarguments to fetch the initial machine state. \Prog{Libunwind} never 1904ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmuses the opaque pointer on its own, but instead just passes it on to 191b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmthe accessor (callback) routines. Typically, this pointer is used to 192b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmselect, e.g., the thread within a process that is to be unwound. 193b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 194b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmOnce a cursor has been initialized with \Func{unw\_init\_remote}(), 195b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmunwinding works exactly like in the local case. That is, you can use 1964ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidm\Func{unw\_step}() to move ``up'' in the call-chain, read and write 197b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmregisters, or resume execution at a particular stack frame by calling 198b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Func{unw\_resume}. 199b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 200b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 201b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\section{Cross-platform and Multi-platform Unwinding} 202b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 203b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Prog{Libunwind} has been designed to enable unwinding across 204b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmplatforms (architectures). Indeed, a single program can use 205b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Prog{libunwind} to unwind an arbitrary number of target platforms, 206b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmall at the same time! 207b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 208b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmWe call the machine that is running \Prog{libunwind} the \emph{host} 209b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmand the machine that is running the process being unwound the 210b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\emph{target}. If the host and the target platform are the same, we 211b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmcall it \emph{native} unwinding. If they differ, we call it 212b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\emph{cross-platform} unwinding. 213b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 214b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmThe principle behind supporting native, cross-platform, and 2154ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmmulti-platform unwinding is very simple: for native unwinding, a 216b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmprogram includes \File{$<$libunwind.h$>$} and uses the linker switch 217b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Opt{-l}\File{unwind}. For cross-platform unwinding, a program 218b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmincludes \File{$<$libunwind-}\Var{PLAT}\File{.h$>$} and uses the linker 219b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmswitch \Opt{-l}\File{unwind-}\Var{PLAT}, where \Var{PLAT} is the name 220b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmof the target platform (e.g., \File{ia64} for IA-64, \File{hppa-elf} 221b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmfor ELF-based HP PA-RISC, or \File{x86} for 80386). Multi-platform 222b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmunwinding works exactly like cross-platform unwinding, the only 223b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmlimitation is that a single source file (compilation unit) can include 224b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmat most one \Prog{libunwind} header file. In other words, the 225b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmplatform-specific support for each supported target needs to be 226b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmisolated in separate source files---a limitation that shouldn't be an 227b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmissue in practice. 228b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 229b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmNote that, by definition, local unwinding is possible only for the 230b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmnative case. Attempting to call, e.g., \Func{unw\_local\_init}() when 231b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmtargeting a cross-platform will result in a link-time error 232b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm(unresolved references). 233b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 234b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 235b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\section{Thread- and Signal-Safety} 236b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 237b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 238b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmAll \Prog{libunwind} routines are thread-safe. What this means is 239b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmthat multiple threads may use \Prog{libunwind} simulatenously. 240b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmHowever, any given cursor may be accessed by only one thread at 241b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmany given time. 242b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 243b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmTo ensure thread-safety, some \Prog{libunwind} routines may have to 244b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmuse locking. Such routines \emph{must~not} be called from signal 245b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmhandlers (directly or indirectly) and are therefore \emph{not} 246b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmsignal-safe. The manual page for each \Prog{libunwind} routine 247b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmidentifies whether or not it is signal-safe, but as a general rule, 248b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmany routine that may be needed for \emph{local} unwinding is 249b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmsignal-safe (e.g., \Func{unw\_step}() for local unwinding is 250b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmsignal-safe). For remote-unwinding, \emph{none} of the 251b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Prog{libunwind} routines are guaranteed to be signal-safe. 252b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 253b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 254b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\section{Unwinding Through Dynamically Generated Code} 255b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 256b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Func{Libunwind} provides the routines \Func{\_U\_dyn\_register}() and 2574ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidm\Func{\_U\_dyn\_cancel}() to register/cancel the information required to 258b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmunwind through code that has been generated at runtime (e.g., by a 259b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmjust-in-time (JIT) compiler). It is important to register the 260b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidminformation for \emph{all} dynamically generated code because 261b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmotherwise, a debugger may not be able to function properly or 262b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmhigh-level language exception handling may not work as expected. 263b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 264b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmThe interface for registering and canceling dynamic unwind info has 265b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmbeen designed for maximum efficiency, so as to minimize the 266b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmperformance impact on JIT-compilers. In particular, both routines are 267b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmguaranteed to execute in ``constant time'' (O(1)) and the 268b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmdata-structure encapsulating the dynamic unwind info has been designed 269b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmto facilitate sharing, such that similar procedures can share much of 270b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmthe underlying information. 271b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 2724ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmFor more information on the \Prog{libunwind} support for dynamically 2734ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidmgenerated code, see \SeeAlso{libunwind-dynamic(3)}. 2744ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidm 275b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 276b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\section{Caching of Unwind Info} 277b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 278b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmTo speed up execution, \Prog{libunwind} may aggressively cache the 279b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidminformation it needs to perform unwinding. If a process changes 280b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmduring its lifetime, this creates a risk of \Prog{libunwind} using 281b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmstale data. For example, this would happen if \Prog{libunwind} were 282b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmto cache information about a shared library which later on gets 283b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmunloaded (e.g., via \Cmd{dlclose}{3}). 284b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 285b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmTo prevent the risk of using stale data, \Prog{libunwind} provides two 286b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmfacilities: first, it is possible to flush the cached information 287b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmassociated with a specific address range in the target process (or the 288b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmentire address space, if desired). This functionality is provided by 289b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Func{unw\_flush\_cache}(). The second facility is provided by 290b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Func{unw\_set\_caching\_policy}(), which lets a program 291b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmselect the exact caching policy in use for a given address-space 292b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmobject. In particular, by selecting the policy 293b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\Const{UNW\_CACHE\_NONE}, it is possible to turn off caching 294b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmcompletely, therefore eliminating the risk of stale data alltogether 295b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm(at the cost of slower execution). By default, caching is enabled for 296b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmlocal unwinding only. 297b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 298b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 299b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\section{Files} 300b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 301b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\begin{Description} 302b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\item[\File{libunwind.h}] Headerfile to include for native (same 303b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm platform) unwinding. 304b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\item[\File{libunwind-}\Var{PLAT}\File{.h}] Headerfile to include when 3054ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidm the unwind target runs on platform \Var{PLAT}. For example, to unwind 306b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm an IA-64 program, the header file \File{libunwind-ia64.h} should be 307b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm included. 308b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\item[\Opt{-l}\File{unwind}] Linker-switch to add when building a 309b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm program that does native (same platform) unwinding. 310b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\item[\Opt{-l}\File{unwind-}\Var{PLAT}] Linker-switch to add when 311b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm building a program that unwinds a program on platform \Var{PLAT}. 312b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm For example, to (cross-)unwind an IA-64 program, the linker switch 313b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm \File{-lunwind-ia64} should be added. Note: multiple such switches 3142a5ff2db57001bc436d9e3d4b55889fb57399e03mostang.com!davidm may need to be specified for programs that can unwind programs on 315b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm multiple platforms. 316b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\end{Description} 317b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 318b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\section{See Also} 319b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 3204ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidm\SeeAlso{libunwind-dynamic(3)}, 321f5892c26be52e370133ea0669762651e88ca3af2mostang.com!davidm\SeeAlso{libunwind-ia64(3)}, 322f5892c26be52e370133ea0669762651e88ca3af2mostang.com!davidm\SeeAlso{libunwind-ptrace(3)}, 323f5892c26be52e370133ea0669762651e88ca3af2mostang.com!davidm\SeeAlso{libunwind-setjmp(3)}, 324a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_create\_addr\_space(3)}, 325a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_destroy\_addr\_space(3)}, 326a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_flush\_cache(3)}, 327a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_get\_accessors(3)}, 328a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_get\_fpreg(3)}, 329a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_get\_proc\_info(3)}, 330a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_get\_proc\_name(3)}, 331a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_get\_reg(3)}, 332a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_getcontext(3)}, 333a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_init\_local(3)}, 334a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_init\_remote(3)}, 335a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_is\_fpreg(3)}, 336a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_is\_signal\_frame(3)}, 337a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_regname(3)}, 338a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_resume(3)}, 339a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_set\_caching\_policy(3)}, 340a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_set\_fpreg(3)}, 341a21507ddb3f0433a7188e47f6050e7129c06567dmostang.com!davidm\SeeAlso{unw\_set\_reg(3)}, 3424ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidm\SeeAlso{unw\_step(3)}, 34375f34ccb7dcdfd2b96e370824b3fd723b2f22b49David Mosberger-Tang\SeeAlso{unw\_strerror(3)}, 3444ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidm\SeeAlso{\_U\_dyn\_register(3)}, 3454ea1dd7fe55efce3c4880fae1f03939d46a3d643mostang.com!davidm\SeeAlso{\_U\_dyn\_cancel(3)} 346b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 347b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\section{Author} 348b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 349b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\noindent 350b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidmDavid Mosberger-Tang\\ 35175f34ccb7dcdfd2b96e370824b3fd723b2f22b49David Mosberger-TangEmail: \Email{dmosberger@gmail.com}\\ 35275f34ccb7dcdfd2b96e370824b3fd723b2f22b49David Mosberger-TangWWW: \URL{http://www.nongnu.org/libunwind/}. 353b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\LatexManEnd 354b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm 355b5a5406e0f043387d41a1e8bfd5fa1772d3f5cd7mostang.com!davidm\end{document} 356