src/xbt/backtrace_windows.c

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