Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Add the backtrace in the table of string only if the symbol and the line information...
[simgrid.git] / src / xbt / ex.c
1 /* $Id$ */
2
3 /* ex - Exception Handling (modified to fit into SimGrid from OSSP version) */
4
5 /*  Copyright (c) 2005, 2006, 2007 Martin Quinson                           */
6 /*  Copyright (c) 2002-2004 Ralf S. Engelschall <rse@engelschall.com>       */
7 /*  Copyright (c) 2002-2004 The OSSP Project <http://www.ossp.org/>         */
8 /*  Copyright (c) 2002-2004 Cable & Wireless <http://www.cw.com/>           */
9 /*  All rights reserved.                                                    */
10
11 /* This program is free software; you can redistribute it and/or modify it
12  * under the terms of the license (GNU LGPL) which comes with this package. */
13
14 #include <stdio.h>
15 #include <stdlib.h>
16
17 #include "portable.h" /* execinfo when available */
18 #include "xbt/ex.h"
19 #include "xbt/str.h"
20 #include "xbt/module.h" /* xbt_binary_name */
21 #include "xbt/synchro.h" /* xbt_thread_self */
22
23 #include "gras/Virtu/virtu_interface.h" /* gras_os_myname */
24 #include "xbt/ex_interface.h"
25
26 #if (defined(WIN32) && defined(_M_IX86))
27 #include <dbghelp.h>
28 #endif
29
30 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_ex,xbt,"Exception mecanism");
31
32 #if (defined(WIN32) && defined(_M_IX86))
33
34 /* 
35  * Win32 (x86) implementation backtrace, backtrace_symbols, backtrace_symbols_fd
36  * : support for application self-debugging.
37  */
38
39 /* Pointer function to SymInitialize() */
40 typedef BOOL (WINAPI *xbt_pfn_sym_initialize_t)(HANDLE, PSTR , BOOL);
41
42 /* Pointer function to SymCleanup() */
43 typedef BOOL (WINAPI *xbt_pfn_sym_cleanup_t)(HANDLE hProcess);
44
45 /* Pointer function to SymFunctionTableAccess() */
46 typedef PVOID (WINAPI *xbt_pfn_sym_function_table_access_t)(HANDLE, DWORD);
47
48 /* Pointer function to SymGetLineFromAddr() */
49 typedef BOOL (WINAPI *xbt_pfn_sym_get_line_from_addr_t)(HANDLE, DWORD, PDWORD , PIMAGEHLP_LINE);
50
51 /* Pointer function to SymGetModuleBase() */
52 typedef DWORD (WINAPI *xbt_pfn_sym_get_module_base_t)(HANDLE,DWORD);
53
54 /* Pointer function to SymGetOptions() */
55 typedef DWORD (WINAPI *xbt_pfn_sym_get_options_t)(VOID);
56
57 /* Pointer function to SymGetSymFromAddr() */
58 typedef BOOL (WINAPI *xbt_pfn_sym_get_sym_from_addr_t)(HANDLE, DWORD, PDWORD , OUT PIMAGEHLP_SYMBOL);
59
60 /* Pointer function to SymSetOptions() */
61 typedef DWORD (WINAPI *xbt_pfn_sym_set_options_t)(DWORD);
62
63 /* Pointer function to StackWalk() */
64 typedef BOOL (WINAPI *xbt_pfn_stack_walk_t)(DWORD, HANDLE, HANDLE ,LPSTACKFRAME, PVOID,PREAD_PROCESS_MEMORY_ROUTINE, PFUNCTION_TABLE_ACCESS_ROUTINE, PGET_MODULE_BASE_ROUTINE, PTRANSLATE_ADDRESS_ROUTINE);
65
66 /* This structure representes the debug_help library used interface */
67 typedef struct s_xbt_debug_help
68 {
69         HINSTANCE instance;
70         HANDLE process_handle;                                                                                  
71         xbt_pfn_sym_initialize_t sym_initialize;
72         xbt_pfn_sym_cleanup_t sym_cleanup;
73         xbt_pfn_sym_function_table_access_t sym_function_table_access;
74         xbt_pfn_sym_get_line_from_addr_t sym_get_line_from_addr;
75         xbt_pfn_sym_get_module_base_t sym_get_module_base;
76         xbt_pfn_sym_get_options_t sym_get_options;
77         xbt_pfn_sym_get_sym_from_addr_t sym_get_sym_from_addr;
78         xbt_pfn_sym_set_options_t sym_set_options;
79         xbt_pfn_stack_walk_t stack_walk;
80 }s_xbt_debug_hlp_t,* xbt_debug_hlp_t;
81
82
83 /* the address to the unique reference to the debug help library interface */
84 static xbt_debug_hlp_t 
85 dbg_hlp = NULL;
86
87 /* initialize the debug help library */
88 static int
89 dbg_hlp_init(HANDLE process_handle);
90
91 /* finalize the debug help library */
92 static int
93 dbg_hlp_finalize(void);
94
95 /*
96  * backtrace() function.
97  *
98  * Returns a backtrace for the calling program, in  the  array
99  * pointed  to  by  buffer.  A backtrace is the series of currently active
100  * function calls for the program.  Each item in the array pointed  to  by
101  * buffer  is  of  type  void *, and is the return address from the corre-
102  * sponding stack frame.  The size argument specifies the  maximum  number
103  * of  addresses that can be stored in buffer.  If the backtrace is larger
104  * than size, then the addresses corresponding to  the  size  most  recent
105  * function  calls  are  returned;  to obtain the complete backtrace, make
106  * sure that buffer and size are large enough.
107  */
108
109 int 
110 backtrace (void **buffer, int size);
111
112 /*
113  * backtrace_symbols() function.
114  *
115  * Given the set of addresses returned by  backtrace()  in  buffer,  back-
116  * trace_symbols()  translates the addresses into an array of strings containing
117  * the name, the source file and the line number or the las called functions.
118  */
119 char ** 
120 backtrace_symbols (void *const *buffer, int size);
121
122 /*
123  * backtrace_symbols_fd() function.
124  *
125  * Same as backtrace_symbols() function but, the the array of strings is wrotten
126  * in a file (fd is the file descriptor of this file)
127  */
128 void 
129 backtrace_symbols_fd(void *const *buffer, int size, int fd);
130 #endif
131
132 /* default __ex_ctx callback function */
133 ex_ctx_t *__xbt_ex_ctx_default(void) {
134   /* Don't scream: this is a default which is never used (so, yes, 
135      there is one setjump container by running entity).
136
137      This default gets overriden in xbt/xbt_os_thread.c so that it works in
138      real life and in simulation when using threads to implement the simulation
139      processes (ie, with pthreads and on windows).
140
141      It also gets overriden in xbt/context.c when using ucontextes (as well as
142      in Java for now, but after the java overhaul, it will get cleaned out)
143   */
144     static ex_ctx_t ctx = XBT_CTX_INITIALIZER;
145
146     return &ctx;
147 }
148
149 /* Change raw libc symbols to file names and line numbers */
150 void xbt_ex_setup_backtrace(xbt_ex_t *e);
151
152 void xbt_backtrace_current(xbt_ex_t *e) {
153 #if defined(HAVE_EXECINFO_H) && defined(HAVE_POPEN) && defined(ADDR2LINE) || (defined(WIN32) && defined(_M_IX86))
154   e->used     = backtrace((void**)e->bt,XBT_BACKTRACE_SIZE);
155   e->bt_strings = NULL;
156   xbt_ex_setup_backtrace(e);
157 #endif
158 }
159
160 void xbt_backtrace_display(xbt_ex_t *e) {
161 #if defined(HAVE_EXECINFO_H) && defined(HAVE_POPEN) && defined(ADDR2LINE) || (defined(WIN32) && defined(_M_IX86))
162   int i;
163
164   if (e->used == 0) {
165      fprintf(stderr,"(backtrace not set)\n");
166   } else {      
167      fprintf(stderr,"Backtrace (displayed in thread %p):\n",
168              (void*)xbt_thread_self());
169      for (i=1; i<e->used; i++) /* no need to display "xbt_display_backtrace" */
170        fprintf(stderr,"---> %s\n",e->bt_strings[i] +4);
171   }
172    
173   /* don't fool xbt_ex_free with uninitialized msg field */
174   e->msg=NULL;
175   e->remote=0;
176   xbt_ex_free(*e);
177 #else 
178
179   ERROR0("No backtrace on this arch");
180 #endif
181 }
182
183 /** \brief show the backtrace of the current point (lovely while debuging) */
184 void xbt_backtrace_display_current(void) {
185   xbt_ex_t e;
186   xbt_backtrace_current(&e);
187   xbt_backtrace_display(&e);
188 }
189
190 #ifndef WIN32
191 extern char **environ; /* the environment, as specified by the opengroup */
192 #endif
193
194 void xbt_ex_setup_backtrace(xbt_ex_t *e)  {
195 #if defined(HAVE_EXECINFO_H) && defined(HAVE_POPEN) && defined(ADDR2LINE)
196   int i;
197   /* to get the backtrace from the libc */
198   char **backtrace = backtrace_symbols (e->bt, e->used);
199   
200   /* To build the commandline of addr2line */
201   char *cmd, *curr;
202   
203   /* to extract the addresses from the backtrace */
204   char **addrs=xbt_new(char*,e->used);
205   char buff[256],*p;
206   
207   /* To read the output of addr2line */
208   FILE *pipe;
209   char line_func[1024],line_pos[1024];
210
211   /* size (in char) of pointers on this arch */
212   int addr_len=0;
213
214   /* To search for the right executable path when not trivial */
215   struct stat stat_buf;
216   char *binary_name = NULL;
217    
218   /* Some arches only have stubs of backtrace, no implementation (hppa comes to mind) */
219   if (!e->used)
220      return;
221    
222   /* build the commandline */
223   if (stat(xbt_binary_name,&stat_buf)) {
224     /* Damn. binary not in current dir. We'll have to dig the PATH to find it */
225     int i;
226     for (i=0; environ[i]; i++) {
227       if (!strncmp("PATH=",environ[i], 5)) {    
228         xbt_dynar_t path=xbt_str_split(environ[i] + 5, ":");
229         unsigned int cpt;
230         char *data;
231         xbt_dynar_foreach(path, cpt, data) {
232           if (binary_name)
233             free(binary_name);
234           binary_name = bprintf("%s/%s",data,xbt_binary_name);
235           if (!stat(binary_name,&stat_buf)) {
236             /* Found. */
237             DEBUG1("Looked in the PATH for the binary. Found %s",binary_name);
238             xbt_dynar_free(&path);
239             break;
240           } 
241         }
242         if (stat(binary_name,&stat_buf)) {
243           /* not found */
244           e->used = 1;
245           e->bt_strings = xbt_new(char*,1);
246           e->bt_strings[0] = bprintf("(binary '%s' not found the path)",xbt_binary_name);
247           return;
248         }
249         xbt_dynar_free(&path);
250         break;
251       } 
252     }
253   } else {
254     binary_name = xbt_strdup(xbt_binary_name);
255   }      
256   cmd = curr = xbt_new(char,strlen(ADDR2LINE)+25+strlen(binary_name)+32*e->used);
257    
258   curr += sprintf(curr,"%s -f -e %s ",ADDR2LINE,binary_name);
259   free(binary_name);
260    
261   for (i=0; i<e->used;i++) {
262     /* retrieve this address */
263     DEBUG2("Retrieving address number %d from '%s'", i, backtrace[i]);
264     snprintf(buff,256,"%s",strchr(backtrace[i],'[')+1);
265     p=strchr(buff,']');
266     *p='\0';
267     if (strcmp(buff,"(nil)"))
268        addrs[i]=bprintf("%s", buff);
269     else
270        addrs[i]=bprintf("0x0");
271     DEBUG3("Set up a new address: %d, '%s'(%p)", i, addrs[i], addrs[i]);
272      
273     /* Add it to the command line args */
274     curr+=sprintf(curr,"%s ",addrs[i]);
275   } 
276   addr_len = strlen(addrs[0]);
277
278   /* parse the output and build a new backtrace */
279   e->bt_strings = xbt_new(char*,e->used);
280   
281   VERB1("Fire a first command: '%s'", cmd);
282   pipe = popen(cmd, "r");
283   if (!pipe) {
284     CRITICAL0("Cannot fork addr2line to display the backtrace");
285     abort();
286   }
287
288   for (i=0; i<e->used; i++) {
289     DEBUG2("Looking for symbol %d, addr = '%s'", i, addrs[i]); 
290     fgets(line_func,1024,pipe);
291     line_func[strlen(line_func)-1]='\0';
292     fgets(line_pos,1024,pipe);
293     line_pos[strlen(line_pos)-1]='\0';
294
295     if (strcmp("??",line_func)) {
296       DEBUG2("Found static symbol %s() at %s", line_func, line_pos);
297       e->bt_strings[i] = bprintf("**   In %s() at %s", line_func,line_pos);
298     } else {
299       /* Damn. The symbol is in a dynamic library. Let's get wild */
300       char *maps_name;
301       FILE *maps;
302       char maps_buff[512];
303
304       long int addr,offset=0;
305       char *p,*p2;
306
307       char *subcmd;
308       FILE *subpipe;
309       int found=0;
310
311       /* let's look for the offset of this library in our addressing space */
312       maps_name=bprintf("/proc/%d/maps",(int)getpid());
313       maps=fopen(maps_name,"r");
314
315       sscanf(addrs[i],"%lx",&addr);
316       sprintf(maps_buff,"%#lx",addr);
317       
318       if (strcmp(addrs[i],maps_buff)) {
319         CRITICAL2("Cannot parse backtrace address '%s' (addr=%#lx)",
320                   addrs[i], addr);
321       }
322       DEBUG2("addr=%s (as string) =%#lx (as number)",addrs[i],addr);
323
324       while (!found) {
325         long int first, last;
326         if (fgets(maps_buff,512,maps) == NULL) 
327           break;
328         if (i==0) {
329           maps_buff[strlen(maps_buff) -1]='\0';
330           DEBUG1("map line: %s", maps_buff);
331         }
332         sscanf(maps_buff,"%lx",&first);
333         p=strchr(maps_buff,'-')+1;
334         sscanf(p,"%lx",&last);
335         if (first < addr && addr < last) {
336           offset = first;
337           found=1;
338         }
339         if (found) {          
340            DEBUG3("%#lx in [%#lx-%#lx]", addr, first,last);
341            DEBUG0("Symbol found, map lines not further displayed (even if looking for next ones)");
342         }
343       }
344       fclose(maps);
345       free(maps_name);
346
347       if (!found) {
348         VERB0("Problem while reading the maps file. Following backtrace will be mangled.");
349         DEBUG1("No dynamic. Static symbol: %s", backtrace[i]);
350         e->bt_strings[i] = bprintf("**   In ?? (%s)", backtrace[i]);
351         continue;
352       }
353
354       /* Ok, Found the offset of the maps line containing the searched symbol. 
355          We now need to substract this from the address we got from backtrace.
356       */
357       
358       free(addrs[i]);
359       addrs[i] = bprintf("0x%0*lx",addr_len-2,addr-offset);
360       DEBUG2("offset=%#lx new addr=%s",offset,addrs[i]);
361
362       /* Got it. We have our new address. Let's get the library path and we 
363          are set */ 
364       p  = xbt_strdup(backtrace[i]);
365       if (p[0]=='[') {
366          /* library path not displayed in the map file either... */
367          free(p);
368          sprintf(line_func,"??");
369       } else {
370          p2 = strrchr(p,'(');
371          if (p2) *p2= '\0';
372          p2 = strrchr(p,' ');
373          if(p2) *p2= '\0';
374       
375          /* Here we go, fire an addr2line up */
376          subcmd = bprintf("%s -f -e %s %s",ADDR2LINE,p, addrs[i]);
377          free(p);
378          VERB1("Fire a new command: '%s'",subcmd);
379          subpipe = popen(subcmd,"r");
380          if (!subpipe) {
381             CRITICAL0("Cannot fork addr2line to display the backtrace");
382             abort();
383          }
384          fgets(line_func,1024,subpipe);
385          line_func[strlen(line_func)-1]='\0';
386          fgets(line_pos,1024,subpipe);
387          line_pos[strlen(line_pos)-1]='\0';
388          pclose(subpipe);
389          free(subcmd);
390       }
391
392       /* check whether the trick worked */
393       if (strcmp("??",line_func)) {
394         DEBUG2("Found dynamic symbol %s() at %s", line_func, line_pos);
395         e->bt_strings[i] = bprintf("**   In %s() at %s", line_func,line_pos);
396       } else {
397         /* damn, nothing to do here. Let's print the raw address */
398         DEBUG1("Dynamic symbol not found. Raw address = %s", backtrace[i]);
399         e->bt_strings[i] = bprintf("**   In ?? at %s", backtrace[i]);
400       }
401       
402     }
403     free(addrs[i]);
404      
405     /* Mask the bottom of the stack */    
406     if (!strncmp("main",line_func,strlen("main")) ||
407         !strncmp("xbt_thread_context_wrapper",line_func,strlen("xbt_thread_context_wrapper"))) {
408        int j;
409        for (j=i+1; j<e->used; j++)
410          free(addrs[j]);
411        e->used = i;
412
413        if (!strncmp("xbt_thread_context_wrapper",line_func,strlen("xbt_thread_context_wrapper"))) {
414           e->used++;
415           e->bt_strings[i] = bprintf("**   (in a separate thread)");
416        }       
417     }
418      
419     
420   }
421   pclose(pipe);
422   free(addrs);
423   free(backtrace);
424   free(cmd);
425 #elif (defined(WIN32) && defined (_M_IX86))
426 int i;
427 char **backtrace = backtrace_symbols (e->bt, e->used);
428   
429   /* parse the output and build a new backtrace */
430   e->bt_strings = xbt_new(char*,e->used);
431   
432
433   for(i=0; i<e->used; i++) 
434   {
435       e->bt_strings[i] = strdup(backtrace[i]);
436       free(backtrace[i]);
437   }
438   
439   free(backtrace);
440 #endif
441 }    
442
443 /** @brief shows an exception content and the associated stack if available */
444 void xbt_ex_display(xbt_ex_t *e)  {
445   char *thrower=NULL;
446
447   if (e->remote)
448     thrower = bprintf(" on host %s(%d)",e->host,e->pid);
449
450   fprintf(stderr,
451           "** SimGrid: UNCAUGHT EXCEPTION received on %s(%d): category: %s; value: %d\n"
452           "** %s\n"
453           "** Thrown by %s()%s\n",
454           gras_os_myname(),(*xbt_getpid)(),
455           xbt_ex_catname(e->category), e->value, e->msg,
456           e->procname,thrower?thrower:" in this process");
457   CRITICAL1("%s",e->msg);
458
459   if (thrower)
460     free(thrower);
461
462   if (!e->remote && !e->bt_strings)
463     xbt_ex_setup_backtrace(e);
464
465 #if (defined(HAVE_EXECINFO_H) && defined(HAVE_POPEN) && defined(ADDR2LINE)) || (defined(WIN32) && defined(_M_IX86))
466   /* We have everything to build neat backtraces */
467   {
468     int i;
469     
470     fprintf(stderr,"\n");
471     for (i=0; i<e->used; i++)
472       fprintf(stderr,"%s\n",e->bt_strings[i]);
473     
474   }
475 #else
476   fprintf(stderr," at %s:%d:%s (no backtrace available on that arch)\n",  
477           e->file,e->line,e->func);
478 #endif
479   xbt_ex_free(*e);
480 }
481
482
483 /* default __ex_terminate callback function */
484 void __xbt_ex_terminate_default(xbt_ex_t *e)  {
485   xbt_ex_display(e);
486
487   abort();
488 }
489
490 /* the externally visible API */
491 XBT_EXPORT_NO_IMPORT(ex_ctx_cb_t)  __xbt_ex_ctx       = &__xbt_ex_ctx_default;
492 XBT_EXPORT_NO_IMPORT(ex_term_cb_t) __xbt_ex_terminate = &__xbt_ex_terminate_default;
493
494
495 void xbt_ex_free(xbt_ex_t e) {
496   int i;
497
498   if (e.msg) free(e.msg);
499   if (e.remote) {
500     free(e.procname);
501     free(e.file);
502     free(e.func);
503     free(e.host);
504   }
505
506   if (e.bt_strings) {   
507      for (i=0; i<e.used; i++) 
508        free((char*)e.bt_strings[i]);
509      free((char **)e.bt_strings);
510   }
511   /* memset(e,0,sizeof(xbt_ex_t)); */
512 }
513
514 /** \brief returns a short name for the given exception category */
515 const char * xbt_ex_catname(xbt_errcat_t cat) {
516   switch (cat) {
517   case unknown_error:   return  "unknown_err";
518   case arg_error:       return "invalid_arg";
519   case mismatch_error:  return "mismatch";
520   case not_found_error: return "not found";
521   case system_error:    return "system_err";
522   case network_error:   return "network_err";
523   case timeout_error:   return "timeout";
524   case thread_error:    return "thread_err";
525   default:              return "INVALID_ERR";
526   }
527 }
528
529 #ifndef HAVE_EXECINFO_H
530 #  if (defined(WIN32) && defined(_M_IX86))
531 int 
532 backtrace (void **buffer, int size)
533 {
534         int pos = 0;
535         STACKFRAME* stack_frame;
536         int first = 1;
537
538         IMAGEHLP_SYMBOL * pSym;
539         unsigned long displacement = 0;
540         IMAGEHLP_LINE line_info = {0};
541         byte __buffer[(sizeof(SYMBOL_INFO) +MAX_SYM_NAME * sizeof(TCHAR) + sizeof(ULONG64) - 1) / sizeof(ULONG64)];
542
543         CONTEXT context = {CONTEXT_FULL};
544         GetThreadContext(GetCurrentThread(), &context);
545         
546         /* ebp pointe sur la base de la pile */
547         /* esp pointe sur le stack pointer <=> sur le dernier élément déposé dans la pile (l'élément courant) */
548         _asm call $+5
549         _asm pop eax 
550         _asm mov context.Eip, eax 
551         _asm mov eax, esp 
552         _asm mov context.Esp, eax 
553         _asm mov context.Ebp, ebp 
554
555         dbg_hlp_init(GetCurrentProcess());
556         
557         if((NULL == dbg_hlp) || (size <= 0) || (NULL == buffer))
558         {
559                 errno = EINVAL;
560                 return 0;
561         }
562
563         for(pos = 0; pos < size; pos++)
564                 buffer[pos] = NULL;
565         
566         pos = 0;
567
568         pSym = (IMAGEHLP_SYMBOL*)__buffer;
569
570         pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL);
571         pSym->MaxNameLength = MAX_SYM_NAME;
572
573
574         line_info.SizeOfStruct = sizeof(IMAGEHLP_LINE);
575         
576
577     while(pos < size)
578     {
579                 stack_frame = (void*)calloc(1,sizeof(STACKFRAME));
580                 
581                 if(!stack_frame)
582                 {
583                         errno = ENOMEM;
584                         break;
585                 }
586                 
587                 stack_frame->AddrPC.Offset = context.Eip;
588             stack_frame->AddrPC.Mode = AddrModeFlat;
589         
590             stack_frame->AddrFrame.Offset = context.Ebp;
591             stack_frame->AddrFrame.Mode = AddrModeFlat;
592         
593             stack_frame->AddrStack.Offset = context.Esp;
594             stack_frame->AddrStack.Mode = AddrModeFlat;
595                 
596                 if((*(dbg_hlp->stack_walk))(
597                                         IMAGE_FILE_MACHINE_I386,
598                                         dbg_hlp->process_handle,
599                                         GetCurrentThread(),
600                                         stack_frame, 
601                                         &context,
602                                         NULL,
603                                         dbg_hlp->sym_function_table_access,
604                                         dbg_hlp->sym_get_module_base,
605                                         NULL)
606                         && !first) 
607                 {
608                         if(stack_frame->AddrReturn.Offset)
609                         {
610
611                                 if((*(dbg_hlp->sym_get_sym_from_addr))(dbg_hlp->process_handle,stack_frame->AddrPC.Offset, &displacement,pSym))
612                                 {       
613                                         if((*(dbg_hlp->sym_get_line_from_addr))(dbg_hlp->process_handle,stack_frame->AddrPC.Offset, &displacement,&line_info))
614                                                 buffer[pos++] = (void*)stack_frame;
615                                 }
616                         }
617                         else
618                         {
619                                 free(stack_frame); /* no symbol or no line info */
620                                 break;
621                         }
622                 }
623                 else
624                 {
625                         free(stack_frame);
626
627                         if(first)
628                                 first = 0;
629                         else
630                                 break;
631                 }               
632     }
633
634     return pos;
635 }
636
637 char ** 
638 backtrace_symbols (void *const *buffer, int size)
639 {
640         int pos;
641         int success = 0;        
642         char** strings;
643         STACKFRAME* stack_frame;
644         char str[MAX_SYM_NAME] = {0};
645         IMAGEHLP_SYMBOL * pSym;
646         unsigned long displacement = 0;
647         IMAGEHLP_LINE line_info = {0};
648         IMAGEHLP_MODULE module = {0};
649         byte __buffer[(sizeof(SYMBOL_INFO) +MAX_SYM_NAME * sizeof(TCHAR) + sizeof(ULONG64) - 1) / sizeof(ULONG64)];
650
651         if((NULL == dbg_hlp) || (size <= 0) || (NULL == buffer))
652         {
653                 errno = EINVAL;
654                 return NULL;
655         }
656         
657         strings = (char**)calloc(size,sizeof(char*));
658         
659         if(NULL == strings)
660         {
661                 errno = ENOMEM;
662                 return NULL;
663         }
664         
665         pSym = (IMAGEHLP_SYMBOL*)__buffer;
666
667         pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL);
668         pSym->MaxNameLength = MAX_SYM_NAME;
669
670
671         line_info.SizeOfStruct = sizeof(IMAGEHLP_LINE);
672         module.SizeOfStruct = sizeof(IMAGEHLP_MODULE);
673         
674         for(pos = 0; pos < size; pos++)
675         {
676                 stack_frame = (STACKFRAME*)(buffer[pos]);
677
678                 if(NULL != stack_frame)
679                 {
680                 
681                         if((*(dbg_hlp->sym_get_sym_from_addr))(dbg_hlp->process_handle,stack_frame->AddrPC.Offset, &displacement,pSym))
682                         {       
683                                 if((*(dbg_hlp->sym_get_line_from_addr))(dbg_hlp->process_handle,stack_frame->AddrPC.Offset, &displacement,&line_info))
684                                 {
685                                         
686                                                 sprintf(str,"**   In %s() at %s:%d", pSym->Name,line_info.FileName,line_info.LineNumber); 
687                                                 
688                                                 strings[pos] = strdup(str);
689                                                 memset(str,0,MAX_SYM_NAME);     
690                                         
691                                                 success = 1;
692                                 }
693                                 else
694                                 {
695                                         strings[pos] = strdup("<no line>");
696                                 }
697                         }
698                         else
699                         {
700                                 strings[pos] = strdup("<no symbole>");
701                         }
702
703                         free(stack_frame);
704                 }
705                 else
706                         break;
707         }
708         
709         if(!success)
710         {
711                 free(strings);
712                 strings = NULL;
713         }
714
715         dbg_hlp_finalize();
716         
717         return strings;
718 }
719
720 void
721 backtrace_symbols_fd(void *const *buffer, int size, int fd)
722 {
723         int pos;
724         int success = 0;        
725         STACKFRAME* stack_frame;
726         char str[MAX_SYM_NAME] = {0};
727         IMAGEHLP_SYMBOL * pSym;
728         unsigned long displacement = 0;
729         IMAGEHLP_LINE line_info = {0};
730         IMAGEHLP_MODULE module = {0};
731
732         byte __buffer[(sizeof(SYMBOL_INFO) +MAX_SYM_NAME * sizeof(TCHAR) + sizeof(ULONG64) - 1) / sizeof(ULONG64)];
733
734         if((NULL == dbg_hlp) || (size <= 0) || (NULL == buffer) || (-1 == fd))
735         {
736                 errno = EINVAL;
737                 return;
738         }
739         
740         pSym = (IMAGEHLP_SYMBOL*)__buffer;
741
742         pSym->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL);
743         pSym->MaxNameLength = MAX_SYM_NAME;
744
745
746         line_info.SizeOfStruct = sizeof(IMAGEHLP_LINE);
747         module.SizeOfStruct = sizeof(IMAGEHLP_MODULE);
748         
749         for(pos = 0; pos < size; pos++)
750         {
751                 stack_frame = (STACKFRAME*)(buffer[pos]);
752
753                 if(NULL != stack_frame)
754                 {
755                 
756                         if((*(dbg_hlp->sym_get_sym_from_addr))(dbg_hlp->process_handle,stack_frame->AddrPC.Offset, &displacement,pSym))
757                         {       
758                                 if((*(dbg_hlp->sym_get_line_from_addr))(dbg_hlp->process_handle,stack_frame->AddrPC.Offset, &displacement,&line_info))
759                                 {
760                                         
761                                                 
762                                                 sprintf(str,"**   In %s() at %s:%d\n", pSym->Name,line_info.FileName,line_info.LineNumber); 
763                                                 
764                                                 if(-1 == write(fd,str,strlen(str)))
765                                                         break;
766
767                                                 memset(str,0,MAX_SYM_NAME);     
768                                         
769                                                 success = 1;
770                                 }
771                         }
772
773                         free(stack_frame);
774                 }
775                 else
776                         break;
777         }
778         
779         dbg_hlp_finalize();
780         
781 }
782
783 static int
784 dbg_hlp_init(HANDLE process_handle)
785 {
786         if(dbg_hlp)
787         {
788                 /* debug help is already loaded */
789                 return 0;
790         }
791
792         /* allocation */
793         dbg_hlp = (xbt_debug_hlp_t)calloc(1,sizeof(s_xbt_debug_hlp_t));
794         
795         if(!dbg_hlp)
796                 return ENOMEM;
797         
798         /* load the library */
799         dbg_hlp->instance = LoadLibraryA("Dbghelp.dll");
800         
801         if(!(dbg_hlp->instance))
802         {
803                 free(dbg_hlp);
804                 dbg_hlp = NULL;
805                 return (int)GetLastError();
806         }
807         
808         /* get the pointers to debug help library exported functions */
809         
810         if(!((dbg_hlp->sym_initialize) = (xbt_pfn_sym_initialize_t)GetProcAddress(dbg_hlp->instance,"SymInitialize")))
811         {
812                 FreeLibrary(dbg_hlp->instance);
813                 free(dbg_hlp);
814                 dbg_hlp = NULL;
815                 return (int)GetLastError();     
816         }
817                 
818         if(!((dbg_hlp->sym_cleanup) = (xbt_pfn_sym_cleanup_t)GetProcAddress(dbg_hlp->instance,"SymCleanup")))
819         {
820                 FreeLibrary(dbg_hlp->instance);
821                 free(dbg_hlp);
822                 dbg_hlp = NULL;
823                 return (int)GetLastError();     
824         }
825         
826         if(!((dbg_hlp->sym_function_table_access) = (xbt_pfn_sym_function_table_access_t)GetProcAddress(dbg_hlp->instance,"SymFunctionTableAccess")))
827         {
828                 FreeLibrary(dbg_hlp->instance);
829                 free(dbg_hlp);
830                 dbg_hlp = NULL;
831                 return (int)GetLastError();     
832         }
833         
834         if(!((dbg_hlp->sym_get_line_from_addr) = (xbt_pfn_sym_get_line_from_addr_t)GetProcAddress(dbg_hlp->instance,"SymGetLineFromAddr")))
835         {
836                 FreeLibrary(dbg_hlp->instance);
837                 free(dbg_hlp);
838                 dbg_hlp = NULL;
839                 return (int)GetLastError();     
840         }
841         
842         if(!((dbg_hlp->sym_get_module_base) = (xbt_pfn_sym_get_module_base_t)GetProcAddress(dbg_hlp->instance,"SymGetModuleBase")))
843         {
844                 FreeLibrary(dbg_hlp->instance);
845                 free(dbg_hlp);
846                 dbg_hlp = NULL;
847                 return (int)GetLastError();     
848         }
849         
850         if(!((dbg_hlp->sym_get_options) = (xbt_pfn_sym_get_options_t)GetProcAddress(dbg_hlp->instance,"SymGetOptions")))
851         {
852                 FreeLibrary(dbg_hlp->instance);
853                 free(dbg_hlp);
854                 dbg_hlp = NULL;
855                 return (int)GetLastError();     
856         }
857         
858         if(!((dbg_hlp->sym_get_sym_from_addr) = (xbt_pfn_sym_get_sym_from_addr_t)GetProcAddress(dbg_hlp->instance,"SymGetSymFromAddr")))
859         {
860                 FreeLibrary(dbg_hlp->instance);
861                 free(dbg_hlp);
862                 dbg_hlp = NULL;
863                 return (int)GetLastError();     
864         }
865         
866         if(!((dbg_hlp->sym_set_options) = (xbt_pfn_sym_set_options_t)GetProcAddress(dbg_hlp->instance,"SymSetOptions")))
867         {
868                 FreeLibrary(dbg_hlp->instance);
869                 free(dbg_hlp);
870                 dbg_hlp = NULL;
871                 return (int)GetLastError();     
872         }
873         
874         if(!((dbg_hlp->stack_walk) = (xbt_pfn_stack_walk_t)GetProcAddress(dbg_hlp->instance,"StackWalk")))
875         {
876                 FreeLibrary(dbg_hlp->instance);
877                 free(dbg_hlp);
878                 dbg_hlp = NULL;
879                 return (int)GetLastError();     
880         }
881         
882         dbg_hlp->process_handle = process_handle;
883
884         (*(dbg_hlp->sym_set_options))((*(dbg_hlp->sym_get_options))() | SYMOPT_LOAD_LINES | SYMOPT_DEFERRED_LOADS);
885         
886         if(!(*(dbg_hlp->sym_initialize))(dbg_hlp->process_handle,0,1))
887         {
888                 FreeLibrary(dbg_hlp->instance);
889                 free(dbg_hlp);
890                 dbg_hlp = NULL;
891                 return (int)GetLastError();
892         }
893                 
894         
895         return 0;
896 }
897
898 static int
899 dbg_hlp_finalize(void)
900 {
901         if(!dbg_hlp)
902                 return EINVAL;
903                 
904         if(!(*(dbg_hlp->sym_cleanup))(dbg_hlp->process_handle))
905                 return (int)GetLastError();
906         
907         if(!FreeLibrary(dbg_hlp->instance))
908                 return (int)GetLastError();
909         
910         free(dbg_hlp);
911         dbg_hlp = NULL;
912         
913         return 0;
914 }
915 #  endif
916 #else
917 /* dummy implementation. We won't use the result, but ex.h needs it to be defined */
918 int backtrace (void **__array, int __size) {
919   return 0;     
920 }
921
922 #endif
923
924 #ifdef SIMGRID_TEST
925 #include <stdio.h>
926 #include "xbt/ex.h"
927
928 XBT_TEST_SUITE("xbt_ex","Exception Handling");
929
930 XBT_TEST_UNIT("controlflow",test_controlflow, "basic nested control flow") {
931     xbt_ex_t ex;
932     volatile int n=1;
933
934     xbt_test_add0("basic nested control flow");
935
936     TRY {
937         if (n != 1)
938             xbt_test_fail1("M1: n=%d (!= 1)", n);
939         n++;
940         TRY {
941             if (n != 2)
942                 xbt_test_fail1("M2: n=%d (!= 2)", n);
943             n++;
944             THROW0(unknown_error,0,"something");
945         } CATCH (ex) {
946             if (n != 3)
947                 xbt_test_fail1("M3: n=%d (!= 3)", n);
948             n++;
949             xbt_ex_free(ex);
950         }
951         n++;
952         TRY {
953             if (n != 5)
954                 xbt_test_fail1("M2: n=%d (!= 5)", n);
955             n++;
956             THROW0(unknown_error,0,"something");
957         } CATCH (ex) {
958             if (n != 6)
959                 xbt_test_fail1("M3: n=%d (!= 6)", n);
960             n++;
961             RETHROW;
962             n++;
963         }
964         xbt_test_fail1("MX: n=%d (shouldn't reach this point)", n);
965     }
966     CATCH(ex) {
967         if (n != 7)
968             xbt_test_fail1("M4: n=%d (!= 7)", n);
969         n++;
970         xbt_ex_free(ex);
971     }
972     if (n != 8)
973         xbt_test_fail1("M5: n=%d (!= 8)", n);
974 }
975
976 XBT_TEST_UNIT("value",test_value,"exception value passing") {
977     xbt_ex_t ex;
978
979     TRY {
980         THROW0(unknown_error, 2, "toto");
981     } CATCH(ex) {
982         xbt_test_add0("exception value passing");
983         if (ex.category != unknown_error)
984             xbt_test_fail1("category=%d (!= 1)", ex.category);
985         if (ex.value != 2)
986             xbt_test_fail1("value=%d (!= 2)", ex.value);
987         if (strcmp(ex.msg,"toto"))
988             xbt_test_fail1("message=%s (!= toto)", ex.msg);
989         xbt_ex_free(ex);
990     }
991 }
992
993 XBT_TEST_UNIT("variables",test_variables,"variable value preservation") {
994     xbt_ex_t ex;
995     int r1, r2;
996     volatile int v1, v2;
997
998     r1 = r2 = v1 = v2 = 1234;
999     TRY {
1000         r2 = 5678;
1001         v2 = 5678;
1002         THROW0(unknown_error, 0, "toto");
1003     } CATCH(ex) {
1004         xbt_test_add0("variable preservation");
1005         if (r1 != 1234)
1006             xbt_test_fail1("r1=%d (!= 1234)", r1);
1007         if (v1 != 1234)
1008             xbt_test_fail1("v1=%d (!= 1234)", v1);
1009         /* r2 is allowed to be destroyed because not volatile */
1010         if (v2 != 5678)
1011             xbt_test_fail1("v2=%d (!= 5678)", v2);
1012         xbt_ex_free(ex);
1013     }
1014 }
1015
1016 XBT_TEST_UNIT("cleanup",test_cleanup,"cleanup handling") {
1017     xbt_ex_t ex;
1018     volatile int v1;
1019     int c;
1020
1021     xbt_test_add0("cleanup handling");
1022
1023     v1 = 1234;
1024     c = 0;
1025     TRY {
1026         v1 = 5678;
1027         THROW0(1, 2, "blah");
1028     } CLEANUP {
1029         if (v1 != 5678)
1030             xbt_test_fail1("v1 = %d (!= 5678)", v1);
1031         c = 1;
1032     } CATCH(ex) {
1033         if (v1 != 5678)
1034             xbt_test_fail1("v1 = %d (!= 5678)", v1);
1035         if (!(ex.category == 1 && ex.value == 2 && !strcmp(ex.msg,"blah")))
1036             xbt_test_fail0("unexpected exception contents");
1037         xbt_ex_free(ex);
1038     }
1039     if (!c)
1040         xbt_test_fail0("xbt_ex_free not executed");
1041 }
1042
1043
1044 /*
1045  * The following is the example included in the documentation. It's a good 
1046  * idea to check its syntax even if we don't try to run it.
1047  * And actually, it allows to put comments in the code despite doxygen.
1048  */ 
1049 static char *mallocex(int size) {
1050   return NULL;
1051 }
1052 #define SMALLAMOUNT 10
1053 #define TOOBIG 100000000
1054
1055 #if 0 /* this contains syntax errors, actually */
1056 static void bad_example(void) {
1057   struct {char*first;} *globalcontext;
1058   ex_t ex;
1059
1060   /* BAD_EXAMPLE */
1061   TRY {
1062     char *cp1, *cp2, *cp3;
1063     
1064     cp1 = mallocex(SMALLAMOUNT);
1065     globalcontext->first = cp1;
1066     cp2 = mallocex(TOOBIG);
1067     cp3 = mallocex(SMALLAMOUNT);
1068     strcpy(cp1, "foo");
1069     strcpy(cp2, "bar");
1070   } CLEANUP {
1071     if (cp3 != NULL) free(cp3);
1072     if (cp2 != NULL) free(cp2);
1073     if (cp1 != NULL) free(cp1);
1074   } CATCH(ex) {
1075     printf("cp3=%s", cp3);
1076     RETHROW;
1077   }
1078   /* end_of_bad_example */
1079 }
1080 #endif
1081 typedef struct {char *first;} global_context_t;
1082    
1083 static void good_example(void) {
1084   global_context_t *global_context=malloc(sizeof(global_context_t));
1085   xbt_ex_t ex;
1086
1087   /* GOOD_EXAMPLE */
1088   { /*01*/
1089     char * volatile /*03*/ cp1 = NULL /*02*/;
1090     char * volatile /*03*/ cp2 = NULL /*02*/;
1091     char * volatile /*03*/ cp3 = NULL /*02*/;
1092     TRY {
1093       cp1 = mallocex(SMALLAMOUNT);
1094       global_context->first = cp1;
1095       cp1 = NULL /*05 give away*/;
1096       cp2 = mallocex(TOOBIG);
1097       cp3 = mallocex(SMALLAMOUNT);
1098       strcpy(cp1, "foo");
1099       strcpy(cp2, "bar");
1100     } CLEANUP { /*04*/
1101       printf("cp3=%s", cp3 == NULL /*02*/ ? "" : cp3);
1102       if (cp3 != NULL)
1103         free(cp3);
1104       if (cp2 != NULL)
1105         free(cp2);
1106       /*05 cp1 was given away */
1107     } CATCH(ex) {
1108       /*05 global context untouched */
1109       RETHROW;
1110     }
1111   }
1112   /* end_of_good_example */
1113 }
1114 #endif /* SIMGRID_TEST */