]> git.saurik.com Git - wxWidgets.git/blob - src/unix/stackwalk.cpp
Reflect changes in stc.cpp in stc.cpp.in from which it's generated.
[wxWidgets.git] / src / unix / stackwalk.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/unix/stackwalk.cpp
3 // Purpose: wxStackWalker implementation for Unix/glibc
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 2005-01-18
7 // Copyright: (c) 2005 Vadim Zeitlin <vadim@wxwindows.org>
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
10
11 // ============================================================================
12 // declarations
13 // ============================================================================
14
15 // ----------------------------------------------------------------------------
16 // headers
17 // ----------------------------------------------------------------------------
18
19 #include "wx/wxprec.h"
20
21 #ifdef __BORLANDC__
22 #pragma hdrstop
23 #endif
24
25 #if wxUSE_STACKWALKER
26
27 #ifndef WX_PRECOMP
28 #include "wx/string.h"
29 #include "wx/app.h"
30 #include "wx/log.h"
31 #include "wx/utils.h"
32 #endif
33
34 #include "wx/stackwalk.h"
35 #include "wx/stdpaths.h"
36
37 #include <execinfo.h>
38
39 #ifdef HAVE_CXA_DEMANGLE
40 #include <cxxabi.h>
41 #endif // HAVE_CXA_DEMANGLE
42
43 // ----------------------------------------------------------------------------
44 // tiny helper wrapper around popen/pclose()
45 // ----------------------------------------------------------------------------
46
47 class wxStdioPipe
48 {
49 public:
50 // ctor parameters are passed to popen()
51 wxStdioPipe(const char *command, const char *type)
52 {
53 m_fp = popen(command, type);
54 }
55
56 // conversion to stdio FILE
57 operator FILE *() const { return m_fp; }
58
59 // dtor closes the pipe
60 ~wxStdioPipe()
61 {
62 if ( m_fp )
63 pclose(m_fp);
64 }
65
66 private:
67 FILE *m_fp;
68
69 wxDECLARE_NO_COPY_CLASS(wxStdioPipe);
70 };
71
72 // ============================================================================
73 // implementation
74 // ============================================================================
75
76 // ----------------------------------------------------------------------------
77 // wxStackFrame
78 // ----------------------------------------------------------------------------
79
80 void wxStackFrame::OnGetName()
81 {
82 if ( !m_name.empty() )
83 return;
84
85 // we already tried addr2line in wxStackWalker::InitFrames: it always
86 // gives us demangled names (even if __cxa_demangle is not available) when
87 // the function is part of the ELF (when it's in a shared object addr2line
88 // will give "??") and because it seems less error-prone.
89 // when it works, backtrace_symbols() sometimes returns incorrect results
90
91 // format is: "module(funcname+offset) [address]" but the part in
92 // parentheses can be not present
93 wxString syminfo = wxString::FromAscii(m_syminfo);
94 const size_t posOpen = syminfo.find(wxT('('));
95 if ( posOpen != wxString::npos )
96 {
97 const size_t posPlus = syminfo.find(wxT('+'), posOpen + 1);
98 if ( posPlus != wxString::npos )
99 {
100 const size_t posClose = syminfo.find(wxT(')'), posPlus + 1);
101 if ( posClose != wxString::npos )
102 {
103 if ( m_name.empty() )
104 {
105 m_name.assign(syminfo, posOpen + 1, posPlus - posOpen - 1);
106
107 #ifdef HAVE_CXA_DEMANGLE
108 int rc = -1;
109 char *cppfunc = __cxxabiv1::__cxa_demangle
110 (
111 m_name.mb_str(),
112 NULL, // output buffer (none, alloc it)
113 NULL, // [out] len of output buffer
114 &rc
115 );
116 if ( rc == 0 )
117 m_name = wxString::FromAscii(cppfunc);
118
119 free(cppfunc);
120 #endif // HAVE_CXA_DEMANGLE
121 }
122
123 unsigned long ofs;
124 if ( wxString(syminfo, posPlus + 1, posClose - posPlus - 1).
125 ToULong(&ofs, 0) )
126 m_offset = ofs;
127 }
128 }
129
130 m_module.assign(syminfo, posOpen);
131 }
132 #ifndef __WXOSX__
133 else // not in "module(funcname+offset)" format
134 {
135 m_module = syminfo;
136 }
137 #endif // !__WXOSX__
138 }
139
140
141 // ----------------------------------------------------------------------------
142 // wxStackWalker
143 // ----------------------------------------------------------------------------
144
145 // that many frames should be enough for everyone
146 #define MAX_FRAMES 200
147
148 // we need a char buffer big enough to contain a call to addr2line with
149 // up to MAX_FRAMES addresses !
150 // NB: %p specifier will print the pointer in hexadecimal form
151 // and thus will require 2 chars for each byte + 3 for the
152 // " 0x" prefix
153 #define CHARS_PER_FRAME (sizeof(void*) * 2 + 3)
154
155 // BUFSIZE will be 2250 for 32 bit machines
156 #define BUFSIZE (50 + MAX_FRAMES*CHARS_PER_FRAME)
157
158 // static data
159 void *wxStackWalker::ms_addresses[MAX_FRAMES];
160 char **wxStackWalker::ms_symbols = NULL;
161 int wxStackWalker::m_depth = 0;
162 wxString wxStackWalker::ms_exepath;
163 static char g_buf[BUFSIZE];
164
165
166 void wxStackWalker::SaveStack(size_t maxDepth)
167 {
168 // read all frames required
169 maxDepth = wxMin(WXSIZEOF(ms_addresses)/sizeof(void*), maxDepth);
170 m_depth = backtrace(ms_addresses, maxDepth*sizeof(void*));
171 if ( !m_depth )
172 return;
173
174 ms_symbols = backtrace_symbols(ms_addresses, m_depth);
175 }
176
177 void wxStackWalker::ProcessFrames(size_t skip)
178 {
179 wxStackFrame frames[MAX_FRAMES];
180
181 if (!ms_symbols || !m_depth)
182 return;
183
184 // we are another level down from Walk(), so adjust the number of stack
185 // frames to skip accordingly
186 skip += 1;
187
188 // call addr2line only once since this call may be very slow
189 // (it has to load in memory the entire EXE of this app which may be quite
190 // big, especially if it contains debug info and is compiled statically!)
191 int numFrames = InitFrames(frames, m_depth - skip,
192 &ms_addresses[skip], &ms_symbols[skip]);
193
194 // now do user-defined operations on each frame
195 for ( int n = 0; n < numFrames; n++ )
196 OnStackFrame(frames[n]);
197 }
198
199 void wxStackWalker::FreeStack()
200 {
201 // ms_symbols has been allocated by backtrace_symbols() and it's the responsibility
202 // of the caller, i.e. us, to free that pointer
203 if (ms_symbols)
204 free( ms_symbols );
205 ms_symbols = NULL;
206 m_depth = 0;
207 }
208
209 namespace
210 {
211
212 // Helper function to read a line from the file and return it without the
213 // trailing newline. Line number is only used for error reporting.
214 bool ReadLine(FILE* fp, unsigned long num, wxString* line)
215 {
216 if ( !fgets(g_buf, WXSIZEOF(g_buf), fp) )
217 {
218 wxLogDebug(wxS("cannot read address information for stack frame #%lu"),
219 num);
220 return false;
221 }
222
223 *line = wxString::FromAscii(g_buf);
224 line->RemoveLast();
225
226 return true;
227 }
228
229 } // anonymous namespace
230
231 int wxStackWalker::InitFrames(wxStackFrame *arr, size_t n, void **addresses, char **syminfo)
232 {
233 // we need to launch addr2line tool to get this information and we need to
234 // have the program name for this
235 wxString exepath = wxStackWalker::GetExePath();
236 if ( exepath.empty() )
237 {
238 exepath = wxStandardPaths::Get().GetExecutablePath();
239 if ( exepath.empty() )
240 {
241 wxLogDebug(wxT("Cannot parse stack frame because the executable ")
242 wxT("path could not be detected"));
243 return 0;
244 }
245 }
246
247 // build the command line for executing addr2line or atos under OS X using
248 // char* directly to avoid the conversions from Unicode
249 #ifdef __WXOSX__
250 int len = snprintf(g_buf, BUFSIZE, "atos -p %d", (int)getpid());
251 #else
252 int len = snprintf(g_buf, BUFSIZE, "addr2line -C -f -e \"%s\"", (const char*) exepath.mb_str());
253 #endif
254 len = (len <= 0) ? strlen(g_buf) : len; // in case snprintf() is broken
255 for (size_t i=0; i<n; i++)
256 {
257 snprintf(&g_buf[len], BUFSIZE - len, " %p", addresses[i]);
258 len = strlen(g_buf);
259 }
260
261 //wxLogDebug(wxT("piping the command '%s'"), g_buf); // for debug only
262
263 wxStdioPipe fp(g_buf, "r");
264 if ( !fp )
265 return 0;
266
267 // parse the output reusing the same buffer to avoid any big memory
268 // allocations which could fail if our program is in a bad state
269 wxString name, filename;
270 unsigned long line = 0,
271 curr = 0;
272 for ( size_t i = 0; i < n; i++ )
273 {
274 #ifdef __WXOSX__
275 wxString buffer;
276 if ( !ReadLine(fp, i, &buffer) )
277 return false;
278
279 line = 0;
280 filename.clear();
281
282 // We can get back either the string in the following format:
283 //
284 // func(args) (in module) (file:line)
285 //
286 // or just the same address back if it couldn't be resolved.
287 const size_t posIn = buffer.find("(in ");
288 if ( posIn != wxString::npos )
289 {
290 name.assign(buffer, 0, posIn);
291
292 size_t posAt = buffer.find(") (", posIn + 3);
293 if ( posAt != wxString::npos )
294 {
295 posAt += 3; // Skip ") ("
296
297 // Discard the two last characters which are ")\n"
298 wxString location(buffer, posAt, buffer.length() - posAt - 2);
299
300 wxString linenum;
301 filename = location.BeforeFirst(':', &linenum);
302 if ( !linenum.empty() )
303 linenum.ToULong(&line);
304 }
305 }
306 #else // !__WXOSX__
307 // 1st line has function name
308 if ( !ReadLine(fp, i, &name) )
309 return false;
310
311 name = wxString::FromAscii(g_buf);
312 name.RemoveLast(); // trailing newline
313
314 if ( name == wxT("??") )
315 name.clear();
316
317 // 2nd one -- the file/line info
318 if ( !ReadLine(fp, i, &filename) )
319 return false;
320
321 const size_t posColon = filename.find(wxT(':'));
322 if ( posColon != wxString::npos )
323 {
324 // parse line number (it's ok if it fails, this will just leave
325 // line at its current, invalid, 0 value)
326 wxString(filename, posColon + 1, wxString::npos).ToULong(&line);
327
328 // remove line number from 'filename'
329 filename.erase(posColon);
330 if ( filename == wxT("??") )
331 filename.clear();
332 }
333 else
334 {
335 wxLogDebug(wxT("Unexpected addr2line format: \"%s\" - ")
336 wxT("the semicolon is missing"),
337 filename.c_str());
338 }
339 #endif // __WXOSX__/!__WXOSX__
340
341 // now we've got enough info to initialize curr-th stack frame
342 // (at worst, only addresses[i] and syminfo[i] have been initialized,
343 // but wxStackFrame::OnGetName may still be able to get function name):
344 arr[curr++].Set(name, filename, syminfo[i], i, line, addresses[i]);
345 }
346
347 return curr;
348 }
349
350 void wxStackWalker::Walk(size_t skip, size_t maxDepth)
351 {
352 // read all frames required
353 SaveStack(maxDepth);
354
355 // process them
356 ProcessFrames(skip);
357
358 // cleanup
359 FreeStack();
360 }
361
362 #endif // wxUSE_STACKWALKER