Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
6ff8b59e955d78d8fe64455fdb192b4c9a347df7
[simgrid.git] / src / xbt / backtrace_windows.c
1 /* $Id$ */
2
3 /* backtrace_windows - backtrace displaying on windows platform             */
4 /* This file is included by ex.c on need (windows x86)                      */
5
6 /*  Copyright (c) 2007 The SimGrid team                                     */
7 /*  All rights reserved.                                                    */
8
9 /* This program is free software; you can redistribute it and/or modify it
10  * under the terms of the license (GNU LGPL) which comes with this package. */
11
12 /* 
13  * Win32 (x86) implementation backtrace, backtrace_symbols:
14  *  support for application self-debugging.
15  */
16
17 #if defined(_XBT_BORLAND_COMPILER) || defined(_XBT_VISUALC_COMPILER)
18   /* native windows build */
19 #  include <dbghelp.h>
20 #else
21   /* gcc-based cross-compiling */
22 #  include "xbt/wine_dbghelp.h"
23 #endif
24
25
26 /* SymInitialize() */
27 typedef BOOL(WINAPI * fun_initialize_t) (HANDLE, PSTR, BOOL);
28 static fun_initialize_t fun_initialize;
29
30 /* SymCleanup() */
31 typedef BOOL(WINAPI * fun_cleanup_t) (HANDLE hProcess);
32 static fun_cleanup_t fun_cleanup;
33
34 /* SymFunctionTableAccess() */
35 typedef PVOID(WINAPI * fun_function_table_access_t) (HANDLE, DWORD);
36 static fun_function_table_access_t fun_function_table_access;
37
38 /* SymGetLineFromAddr() */
39 typedef BOOL(WINAPI * fun_get_line_from_addr_t) (HANDLE, DWORD,
40                                                  PDWORD,
41                                                  PIMAGEHLP_LINE);
42 static fun_get_line_from_addr_t fun_get_line_from_addr;
43
44 /* SymGetModuleBase() */
45 typedef DWORD(WINAPI *fun_get_module_base_t) (HANDLE, DWORD);
46 static fun_get_module_base_t fun_get_module_base;
47
48 /* SymGetOptions() */
49 typedef DWORD(WINAPI *fun_get_options_t) (VOID);
50 static fun_get_options_t fun_get_options;
51
52 /* SymSetOptions() */
53 typedef DWORD(WINAPI *fun_set_options_t) (DWORD);
54 static fun_set_options_t fun_set_options;
55
56 /* Pointer function to SymGetSymFromAddr() */
57 typedef BOOL(WINAPI *fun_get_sym_from_addr_t) (HANDLE, DWORD, PDWORD,
58                                                OUT PIMAGEHLP_SYMBOL);
59 static fun_get_sym_from_addr_t fun_get_sym_from_addr;
60
61 /* Pointer function to StackWalk() */
62 typedef BOOL(WINAPI * fun_stack_walk_t) (DWORD, HANDLE, HANDLE,
63                                             LPSTACKFRAME, PVOID,
64                                             PREAD_PROCESS_MEMORY_ROUTINE,
65                                             PFUNCTION_TABLE_ACCESS_ROUTINE,
66                                             PGET_MODULE_BASE_ROUTINE,
67                                             PTRANSLATE_ADDRESS_ROUTINE);
68 static fun_stack_walk_t fun_stack_walk;
69
70 static HINSTANCE hlp_dbg_instance = NULL;
71 static HANDLE process_handle = NULL;
72
73
74 /* Module creation/destruction: nothing to do on linux */
75 void xbt_backtrace_init(void) { 
76   process_handle = GetCurrentProcess();
77
78   if (hlp_dbg_instance) {
79     /* debug help is already loaded */
80     return;
81   }
82
83   /* load the library */
84   hlp_dbg_instance = LoadLibraryA("Dbghelp.dll");
85
86   if (!hlp_dbg_instance)
87     return;
88  
89   /* get the pointers to debug help library exported functions */
90   fun_initialize = 
91      (fun_initialize_t) GetProcAddress(hlp_dbg_instance, "SymInitialize");
92   fun_cleanup = 
93      (fun_cleanup_t) GetProcAddress(hlp_dbg_instance, "SymCleanup");
94   fun_function_table_access = 
95      (fun_function_table_access_t) GetProcAddress(hlp_dbg_instance, "SymFunctionTableAccess");
96   fun_get_line_from_addr = 
97      (fun_get_line_from_addr_t) GetProcAddress(hlp_dbg_instance, "SymGetLineFromAddr");
98   fun_get_module_base = 
99      (fun_get_module_base_t) GetProcAddress(hlp_dbg_instance, "SymGetModuleBase");
100   fun_get_options = 
101      (fun_get_options_t) GetProcAddress(hlp_dbg_instance, "SymGetOptions");
102   fun_get_sym_from_addr = 
103      (fun_get_sym_from_addr_t) GetProcAddress(hlp_dbg_instance, "SymGetSymFromAddr");
104   fun_set_options = 
105      (fun_set_options_t) GetProcAddress(hlp_dbg_instance, "SymSetOptions");
106   fun_stack_walk = 
107      (fun_stack_walk_t) GetProcAddress(hlp_dbg_instance, "StackWalk");
108
109   /* Check that everything worked well */
110   if (!fun_initialize ||
111       !fun_cleanup ||
112       !fun_function_table_access || 
113       !fun_get_line_from_addr ||
114       !fun_get_module_base ||
115       !fun_get_options ||
116       !fun_get_sym_from_addr ||
117       !fun_set_options ||
118       !fun_stack_walk
119       ) {
120     FreeLibrary(hlp_dbg_instance);
121     hlp_dbg_instance = NULL;
122     return;
123   }
124
125   (*fun_set_options) ((*fun_get_options) () |
126                         SYMOPT_LOAD_LINES | SYMOPT_DEFERRED_LOADS);
127
128   if (!(*fun_initialize) (process_handle, 0, 1)) {
129     FreeLibrary(hlp_dbg_instance);
130     hlp_dbg_instance = NULL;
131   }
132 }
133 void xbt_backtrace_exit(void) { 
134   if (!hlp_dbg_instance)
135     return;
136
137   if ((*fun_cleanup) (process_handle))
138     FreeLibrary(hlp_dbg_instance);
139
140   hlp_dbg_instance = NULL;
141 }
142
143 /*
144  * backtrace() function.
145  *
146  * Returns a backtrace for the calling program, in  the  array
147  * pointed  to  by  buffer.  A backtrace is the series of currently active
148  * function calls for the program.  Each item in the array pointed  to  by
149  * buffer  is  of  type  void *, and is the return address from the corre-
150  * sponding stack frame.  The size argument specifies the  maximum  number
151  * of  addresses that can be stored in buffer.  If the backtrace is larger
152  * than size, then the addresses corresponding to  the  size  most  recent
153  * function  calls  are  returned;  to obtain the complete backtrace, make
154  * sure that buffer and size are large enough.
155  */
156
157 int backtrace(void **buffer, int size);
158
159 /*
160  * backtrace_symbols() function.
161  *
162  * Given the set of addresses returned by  backtrace()  in  buffer,  back-
163  * trace_symbols()  translates the addresses into an array of strings containing
164  * the name, the source file and the line number or the las called functions.
165  */
166 char **backtrace_symbols(void *const *buffer, int size);
167
168 void xbt_ex_setup_backtrace(xbt_ex_t * e)
169 {
170   int i;
171   char **backtrace_syms = backtrace_symbols(e->bt, e->used);
172
173   e->used = backtrace((void **) e->bt, XBT_BACKTRACE_SIZE);
174   e->bt_strings = NULL;
175   /* parse the output and build a new backtrace */
176   e->bt_strings = xbt_new(char *, e->used);
177
178
179   for (i = 0; i < e->used; i++)
180     e->bt_strings[i] = backtrace_syms[i];
181
182   free(backtrace_syms);
183 }
184
185 int backtrace(void **buffer, int size)
186 {
187   int pos = 0;
188   STACKFRAME *stack_frame;
189   int first = 1;
190
191   IMAGEHLP_SYMBOL *pSym;
192   unsigned long offset = 0;
193   IMAGEHLP_LINE line_info = { 0 };
194   byte
195     __buffer[(sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR) +
196               sizeof(ULONG64) - 1) / sizeof(ULONG64)];
197
198   CONTEXT context = { CONTEXT_FULL };
199   GetThreadContext(GetCurrentThread(), &context);
200
201   /* ebp points on stack base */
202   /* esp points on stack pointer, ie on last stacked element (current element) */
203 //  asm ("call $ + 5"); FIXME: this does not works when cross-compiling. Is this really mandatory?
204   asm ("pop %eax");
205   asm ("mov context.Eip, %eax");
206   asm ("mov %eax, %esp");
207   asm ("mov context.Esp, %eax");
208   asm ("mov context.Ebp, %ebp");
209
210   if ((NULL == hlp_dbg_instance) || (size <= 0) || (NULL == buffer)) {
211     errno = EINVAL;
212     return 0;
213   }
214
215   for (pos = 0; pos < size; pos++)
216     buffer[pos] = NULL;
217
218   pos = 0;
219
220   pSym = (IMAGEHLP_SYMBOL *) __buffer;
221
222   pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL);
223   pSym->MaxNameLength = MAX_SYM_NAME;
224
225
226   line_info.SizeOfStruct = sizeof(IMAGEHLP_LINE);
227
228
229   while (pos < size) {
230     stack_frame = (void *) xbt_new0(STACKFRAME, 1);
231
232     stack_frame->AddrPC.Offset = context.Eip;
233     stack_frame->AddrPC.Mode = AddrModeFlat;
234
235     stack_frame->AddrFrame.Offset = context.Ebp;
236     stack_frame->AddrFrame.Mode = AddrModeFlat;
237
238     stack_frame->AddrStack.Offset = context.Esp;
239     stack_frame->AddrStack.Mode = AddrModeFlat;
240
241     if ((*fun_stack_walk) (IMAGE_FILE_MACHINE_I386,
242                            process_handle,
243                            GetCurrentThread(),
244                            stack_frame,
245                            &context,
246                            NULL,
247                            fun_function_table_access,
248                            fun_get_module_base, NULL)
249         && !first) {
250       if (stack_frame->AddrReturn.Offset) {
251
252         if ((*fun_get_sym_from_addr) (process_handle, stack_frame->AddrPC.Offset, &offset, pSym)) {
253           if ((*fun_get_line_from_addr) (process_handle, stack_frame->AddrPC.Offset, &offset, &line_info))
254             buffer[pos++] = (void *) stack_frame;
255         }
256       } else {
257         free(stack_frame);      /* no symbol or no line info */
258         break;
259       }
260     } else {
261       free(stack_frame);
262
263       if (first)
264         first = 0;
265       else
266         break;
267     }
268   }
269
270   return pos;
271 }
272
273 char **backtrace_symbols(void *const *buffer, int size)
274 {
275   int pos;
276   int success = 0;
277   char **strings;
278   STACKFRAME *stack_frame;
279   IMAGEHLP_SYMBOL *pSym;
280   unsigned long offset = 0;
281   IMAGEHLP_LINE line_info = { 0 };
282   IMAGEHLP_MODULE module = { 0 };
283   byte
284     __buffer[(sizeof(SYMBOL_INFO) + MAX_SYM_NAME * sizeof(TCHAR) +
285               sizeof(ULONG64) - 1) / sizeof(ULONG64)];
286
287   if ((NULL == hlp_dbg_instance) || (size <= 0) || (NULL == buffer)) {
288     errno = EINVAL;
289     return NULL;
290   }
291
292   strings = xbt_new0(char *, size);
293
294   pSym = (IMAGEHLP_SYMBOL *) __buffer;
295
296   pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL);
297   pSym->MaxNameLength = MAX_SYM_NAME;
298
299
300   line_info.SizeOfStruct = sizeof(IMAGEHLP_LINE);
301   module.SizeOfStruct = sizeof(IMAGEHLP_MODULE);
302
303   for (pos = 0; pos < size; pos++) {
304     stack_frame = (STACKFRAME *) (buffer[pos]);
305
306     if (NULL != stack_frame) {
307
308       if ((*fun_get_sym_from_addr) (process_handle, stack_frame->AddrPC.Offset, &offset, pSym)) {
309         if ((*fun_get_line_from_addr) (process_handle, stack_frame->AddrPC.Offset, &offset, &line_info)) {
310           strings[pos] =
311             bprintf("**   In %s() at %s:%d", pSym->Name, line_info.FileName,
312                     (int)line_info.LineNumber);
313         } else {
314           strings[pos] = bprintf("**   In %s()", pSym->Name);
315         }
316         success = 1;
317       } else {
318         strings[pos] = xbt_strdup("**   <no symbol>");
319       }
320
321       free(stack_frame);
322     } else
323       break;
324   }
325
326   if (!success) {
327     free(strings);
328     strings = NULL;
329   }
330
331   return strings;
332 }