src/msw/debughlp.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/debughlp.cpp
   3 // Purpose:     various Win32 debug helpers
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     2005-01-08 (extracted from crashrpt.cpp)
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2003-2005 Vadim Zeitlin <vadim@wxwindows.org>
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #include "wx/wxprec.h"
  21
  22 #ifdef __BORLANDC__
  23     #pragma hdrstop
  24 #endif
  25
  26 #include "wx/msw/debughlp.h"
  27
  28 #if wxUSE_DBGHELP
  29
  30 // ----------------------------------------------------------------------------
  31 // globals
  32 // ----------------------------------------------------------------------------
  33
  34 // error message from Init()
  35 static wxString gs_errMsg;
  36
  37 // ============================================================================
  38 // wxDbgHelpDLL implementation
  39 // ============================================================================
  40
  41 // ----------------------------------------------------------------------------
  42 // static members
  43 // ----------------------------------------------------------------------------
  44
  45 #define DEFINE_SYM_FUNCTION(func) wxDbgHelpDLL::func ## _t wxDbgHelpDLL::func = 0
  46
  47 wxDO_FOR_ALL_SYM_FUNCS(DEFINE_SYM_FUNCTION);
  48
  49 #undef DEFINE_SYM_FUNCTION
  50
  51 // ----------------------------------------------------------------------------
  52 // initialization methods
  53 // ----------------------------------------------------------------------------
  54
  55 // load all function we need from the DLL
  56
  57 static bool BindDbgHelpFunctions(const wxDynamicLibrary& dllDbgHelp)
  58 {
  59     #define LOAD_SYM_FUNCTION(name)                                           \
  60         wxDbgHelpDLL::name = (wxDbgHelpDLL::name ## _t)                       \
  61                                 dllDbgHelp.GetSymbol(_T(#name));              \
  62         if ( !wxDbgHelpDLL::name )                                            \
  63         {                                                                     \
  64             gs_errMsg += _T("Function ") _T(#name) _T("() not found.\n");     \
  65             return false;                                                     \
  66         }
  67
  68     wxDO_FOR_ALL_SYM_FUNCS(LOAD_SYM_FUNCTION);
  69
  70     #undef LOAD_SYM_FUNCTION
  71
  72     return true;
  73 }
  74
  75 // called by Init() if we hadn't done this before
  76 static bool DoInit()
  77 {
  78     wxDynamicLibrary dllDbgHelp(_T("dbghelp.dll"), wxDL_VERBATIM);
  79     if ( dllDbgHelp.IsLoaded() )
  80     {
  81         if ( BindDbgHelpFunctions(dllDbgHelp) )
  82         {
  83             // turn on default options
  84             DWORD options = wxDbgHelpDLL::SymGetOptions();
  85
  86             options |= SYMOPT_DEFERRED_LOADS | SYMOPT_UNDNAME | SYMOPT_DEBUG;
  87
  88             wxDbgHelpDLL::SymSetOptions(options);
  89
  90             dllDbgHelp.Detach();
  91             return true;
  92         }
  93
  94         gs_errMsg += _T("\nPlease update your dbghelp.dll version, ")
  95                      _T("at least version 5.1 is needed!\n")
  96                      _T("(if you already have a new version, please ")
  97                      _T("put it in the same directory where the program is.)\n");
  98     }
  99     else // failed to load dbghelp.dll
 100     {
 101         gs_errMsg += _T("Please install dbghelp.dll available free of charge ")
 102                      _T("from Microsoft to get more detailed crash information!");
 103     }
 104
 105     gs_errMsg += _T("\nLatest dbghelp.dll is available at ")
 106                  _T("http://www.microsoft.com/whdc/ddk/debugging/\n");
 107
 108     return false;
 109 }
 110
 111 /* static */
 112 bool wxDbgHelpDLL::Init()
 113 {
 114     // this flag is -1 until Init() is called for the first time, then it's set
 115     // to either false or true depending on whether we could load the functions
 116     static int s_loaded = -1;
 117
 118     if ( s_loaded == -1 )
 119     {
 120         s_loaded = DoInit();
 121     }
 122
 123     return s_loaded != 0;
 124 }
 125
 126 // ----------------------------------------------------------------------------
 127 // error handling
 128 // ----------------------------------------------------------------------------
 129
 130 /* static */
 131 const wxString& wxDbgHelpDLL::GetErrorMessage()
 132 {
 133     return gs_errMsg;
 134 }
 135
 136 /* static */
 137 void wxDbgHelpDLL::LogError(const wxChar *func)
 138 {
 139     ::OutputDebugString(wxString::Format(_T("dbghelp: %s() failed: %s\r\n"),
 140                         func, wxSysErrorMsg(::GetLastError())));
 141 }
 142
 143 // ----------------------------------------------------------------------------
 144 // data dumping
 145 // ----------------------------------------------------------------------------
 146
 147 static inline
 148 bool
 149 DoGetTypeInfo(DWORD64 base, ULONG ti, IMAGEHLP_SYMBOL_TYPE_INFO type, void *rc)
 150 {
 151     static HANDLE s_hProcess = ::GetCurrentProcess();
 152
 153     return wxDbgHelpDLL::SymGetTypeInfo
 154                          (
 155                             s_hProcess,
 156                             base,
 157                             ti,
 158                             type,
 159                             rc
 160                          ) != 0;
 161 }
 162
 163 static inline
 164 bool
 165 DoGetTypeInfo(PSYMBOL_INFO pSym, IMAGEHLP_SYMBOL_TYPE_INFO type, void *rc)
 166 {
 167     return DoGetTypeInfo(pSym->ModBase, pSym->TypeIndex, type, rc);
 168 }
 169
 170 static inline
 171 wxDbgHelpDLL::BasicType GetBasicType(PSYMBOL_INFO pSym)
 172 {
 173     wxDbgHelpDLL::BasicType bt;
 174     return DoGetTypeInfo(pSym, TI_GET_BASETYPE, &bt)
 175             ? bt
 176             : wxDbgHelpDLL::BASICTYPE_NOTYPE;
 177 }
 178
 179 /* static */
 180 wxString wxDbgHelpDLL::GetSymbolName(PSYMBOL_INFO pSym)
 181 {
 182     wxString s;
 183
 184     WCHAR *pwszTypeName;
 185     if ( SymGetTypeInfo
 186          (
 187             GetCurrentProcess(),
 188             pSym->ModBase,
 189             pSym->TypeIndex,
 190             TI_GET_SYMNAME,
 191             &pwszTypeName
 192          ) )
 193     {
 194         s = wxConvCurrent->cWC2WX(pwszTypeName);
 195
 196         ::LocalFree(pwszTypeName);
 197     }
 198
 199     return s;
 200 }
 201
 202 /* static */ wxString
 203 wxDbgHelpDLL::DumpBaseType(BasicType bt, DWORD64 length, PVOID pAddress)
 204 {
 205     if ( !pAddress )
 206     {
 207         return _T("null");
 208     }
 209
 210     if ( ::IsBadReadPtr(pAddress, length) != 0 )
 211     {
 212         return _T("BAD");
 213     }
 214
 215
 216     wxString s;
 217     s.reserve(256);
 218
 219     if ( length == 1 )
 220     {
 221         const BYTE b = *(PBYTE)pAddress;
 222
 223         if ( bt == BASICTYPE_BOOL )
 224             s = b ? _T("true") : _T("false");
 225         else
 226             s.Printf(_T("%#04x"), b);
 227     }
 228     else if ( length == 2 )
 229     {
 230         s.Printf(bt == BASICTYPE_UINT ? _T("%#06x") : _T("%d"),
 231                  *(PWORD)pAddress);
 232     }
 233     else if ( length == 4 )
 234     {
 235         bool handled = false;
 236
 237         if ( bt == BASICTYPE_FLOAT )
 238         {
 239             s.Printf(_T("%f"), *(PFLOAT)pAddress);
 240
 241             handled = true;
 242         }
 243         else if ( bt == BASICTYPE_CHAR )
 244         {
 245             // don't take more than 32 characters of a string
 246             static const size_t NUM_CHARS = 64;
 247
 248             const char *pc = *(PSTR *)pAddress;
 249             if ( ::IsBadStringPtrA(pc, NUM_CHARS) == 0 )
 250             {
 251                 s += _T('"');
 252                 for ( size_t n = 0; n < NUM_CHARS && *pc; n++, pc++ )
 253                 {
 254                     s += *pc;
 255                 }
 256                 s += _T('"');
 257
 258                 handled = true;
 259             }
 260         }
 261
 262         if ( !handled )
 263         {
 264             // treat just as an opaque DWORD
 265             s.Printf(_T("%#x"), *(PDWORD)pAddress);
 266         }
 267     }
 268     else if ( length == 8 )
 269     {
 270         if ( bt == BASICTYPE_FLOAT )
 271         {
 272             s.Printf(_T("%lf"), *(double *)pAddress);
 273         }
 274         else // opaque 64 bit value
 275         {
 276             s.Printf(_T("%#" wxLongLongFmtSpec _T("x")), *(PDWORD *)pAddress);
 277         }
 278     }
 279
 280     return s;
 281 }
 282
 283 wxString
 284 wxDbgHelpDLL::DumpField(PSYMBOL_INFO pSym, void *pVariable, unsigned level)
 285 {
 286     wxString s;
 287
 288     // avoid infinite recursion
 289     if ( level > 100 )
 290     {
 291         return s;
 292     }
 293
 294     SymbolTag tag = SYMBOL_TAG_NULL;
 295     if ( !DoGetTypeInfo(pSym, TI_GET_SYMTAG, &tag) )
 296     {
 297         return s;
 298     }
 299
 300     switch ( tag )
 301     {
 302         case SYMBOL_TAG_UDT:
 303         case SYMBOL_TAG_BASE_CLASS:
 304             s = DumpUDT(pSym, pVariable, level);
 305             break;
 306
 307         case SYMBOL_TAG_DATA:
 308             wxDbgHelpDLL::DataKind kind;
 309             if ( !DoGetTypeInfo(pSym, TI_GET_DATAKIND, &kind) ||
 310                     kind != DATA_MEMBER )
 311             {
 312                 // maybe it's a static member? we're not interested in them...
 313                 break;
 314             }
 315
 316             // get the offset of the child member, relative to its parent
 317             DWORD ofs = 0;
 318             if ( !DoGetTypeInfo(pSym, TI_GET_OFFSET, &ofs) )
 319                 break;
 320
 321             pVariable = (void *)((DWORD_PTR)pVariable + ofs);
 322
 323
 324             // now pass to the type representing the type of this member
 325             SYMBOL_INFO sym = *pSym;
 326             if ( !DoGetTypeInfo(pSym, TI_GET_TYPEID, &sym.TypeIndex) )
 327                 break;
 328
 329             ULONG64 size;
 330             DoGetTypeInfo(&sym, TI_GET_LENGTH, &size);
 331
 332             switch ( DereferenceSymbol(&sym, &pVariable) )
 333             {
 334                 case SYMBOL_TAG_BASE_TYPE:
 335                     {
 336                         BasicType bt = GetBasicType(&sym);
 337                         if ( bt )
 338                         {
 339                             s = DumpBaseType(bt, size, pVariable);
 340                         }
 341                     }
 342                     break;
 343
 344                 case SYMBOL_TAG_UDT:
 345                 case SYMBOL_TAG_BASE_CLASS:
 346                     s = DumpUDT(&sym, pVariable, level);
 347                     break;
 348             }
 349
 350             if ( !s.empty() )
 351             {
 352                 s = GetSymbolName(pSym) + _T(" = ") + s;
 353             }
 354             break;
 355     }
 356
 357     if ( !s.empty() )
 358     {
 359         s = wxString(_T('\t'), level + 1) + s + _T('\n');
 360     }
 361
 362     return s;
 363 }
 364
 365 /* static */ wxString
 366 wxDbgHelpDLL::DumpUDT(PSYMBOL_INFO pSym, void *pVariable, unsigned level)
 367 {
 368     wxString s;
 369     s.reserve(512);
 370     s = GetSymbolName(pSym);
 371
 372 #if !wxUSE_STL
 373     // special handling for ubiquitous wxString: although the code below works
 374     // for it as well, it shows the wxStringBase class and takes 4 lines
 375     // instead of only one as this branch
 376     if ( s == _T("wxString") )
 377     {
 378         wxString *ps = (wxString *)pVariable;
 379         s << _T("(\"") << *ps << _T(")\"");
 380     }
 381     else // any other UDT
 382 #endif // !wxUSE_STL
 383     {
 384         // Determine how many children this type has.
 385         DWORD dwChildrenCount = 0;
 386         DoGetTypeInfo(pSym, TI_GET_CHILDRENCOUNT, &dwChildrenCount);
 387
 388         // Prepare to get an array of "TypeIds", representing each of the children.
 389         TI_FINDCHILDREN_PARAMS *children = (TI_FINDCHILDREN_PARAMS *)
 390             malloc(sizeof(TI_FINDCHILDREN_PARAMS) +
 391                         (dwChildrenCount - 1)*sizeof(ULONG));
 392         if ( !children )
 393             return s;
 394
 395         children->Count = dwChildrenCount;
 396         children->Start = 0;
 397
 398         // Get the array of TypeIds, one for each child type
 399         if ( !DoGetTypeInfo(pSym, TI_FINDCHILDREN, children) )
 400         {
 401             free(children);
 402             return s;
 403         }
 404
 405         s << _T(" {\n");
 406
 407         // Iterate through all children
 408         SYMBOL_INFO sym;
 409         wxZeroMemory(sym);
 410         sym.ModBase = pSym->ModBase;
 411         for ( unsigned i = 0; i < dwChildrenCount; i++ )
 412         {
 413             sym.TypeIndex = children->ChildId[i];
 414
 415             // children here are in lexicographic sense, i.e. we get all our nested
 416             // classes and not only our member fields, but we can't get the values
 417             // for the members of the nested classes, of course!
 418             DWORD nested;
 419             if ( DoGetTypeInfo(&sym, TI_GET_NESTED, &nested) && nested )
 420                 continue;
 421
 422             // avoid infinite recursion: this does seem to happen sometimes with
 423             // complex typedefs...
 424             if ( sym.TypeIndex == pSym->TypeIndex )
 425                 continue;
 426
 427             s += DumpField(&sym, pVariable, level + 1);
 428         }
 429
 430         free(children);
 431
 432         s << wxString(_T('\t'), level + 1) << _T('}');
 433     }
 434
 435     return s;
 436 }
 437
 438 /* static */
 439 wxDbgHelpDLL::SymbolTag
 440 wxDbgHelpDLL::DereferenceSymbol(PSYMBOL_INFO pSym, void **ppData)
 441 {
 442     SymbolTag tag = SYMBOL_TAG_NULL;
 443     for ( ;; )
 444     {
 445         if ( !DoGetTypeInfo(pSym, TI_GET_SYMTAG, &tag) )
 446             break;
 447
 448         if ( tag != SYMBOL_TAG_POINTER_TYPE )
 449             break;
 450
 451         ULONG tiNew;
 452         if ( !DoGetTypeInfo(pSym, TI_GET_TYPEID, &tiNew) ||
 453                 tiNew == pSym->TypeIndex )
 454             break;
 455
 456         pSym->TypeIndex = tiNew;
 457
 458         // remove one level of indirection except for the char strings: we want
 459         // to dump "char *" and not a single "char" for them
 460         if ( ppData && *ppData && GetBasicType(pSym) != BASICTYPE_CHAR )
 461             *ppData = (void *)*((DWORD_PTR *)*ppData);
 462     }
 463
 464     return tag;
 465 }
 466
 467 /* static */ wxString
 468 wxDbgHelpDLL::DumpSymbol(PSYMBOL_INFO pSym, void *pVariable)
 469 {
 470     wxString s;
 471     SYMBOL_INFO symDeref = *pSym;
 472     switch ( DereferenceSymbol(&symDeref, &pVariable) )
 473     {
 474         case SYMBOL_TAG_UDT:
 475             // show UDT recursively
 476             s = DumpUDT(&symDeref, pVariable);
 477             break;
 478
 479         case SYMBOL_TAG_BASE_TYPE:
 480             // variable of simple type, show directly
 481             BasicType bt = GetBasicType(&symDeref);
 482             if ( bt )
 483             {
 484                 s = DumpBaseType(bt, pSym->Size, pVariable);
 485             }
 486             break;
 487     }
 488
 489     return s;
 490 }
 491
 492 // ----------------------------------------------------------------------------
 493 // debugging helpers
 494 // ----------------------------------------------------------------------------
 495
 496 // this code is very useful when debugging debughlp.dll-related code but
 497 // probably not worth having compiled in normally, please do not remove it!
 498 #if 0 // ndef NDEBUG
 499
 500 static wxString TagString(wxDbgHelpDLL::SymbolTag tag)
 501 {
 502     static const wxChar *tags[] =
 503     {
 504         _T("null"),
 505         _T("exe"),
 506         _T("compiland"),
 507         _T("compiland details"),
 508         _T("compiland env"),
 509         _T("function"),
 510         _T("block"),
 511         _T("data"),
 512         _T("annotation"),
 513         _T("label"),
 514         _T("public symbol"),
 515         _T("udt"),
 516         _T("enum"),
 517         _T("function type"),
 518         _T("pointer type"),
 519         _T("array type"),
 520         _T("base type"),
 521         _T("typedef"),
 522         _T("base class"),
 523         _T("friend"),
 524         _T("function arg type"),
 525         _T("func debug start"),
 526         _T("func debug end"),
 527         _T("using namespace"),
 528         _T("vtable shape"),
 529         _T("vtable"),
 530         _T("custom"),
 531         _T("thunk"),
 532         _T("custom type"),
 533         _T("managed type"),
 534         _T("dimension"),
 535     };
 536
 537     wxCOMPILE_TIME_ASSERT( WXSIZEOF(tags) == wxDbgHelpDLL::SYMBOL_TAG_MAX,
 538                                 SymbolTagStringMismatch );
 539
 540     wxString s;
 541     if ( tag < WXSIZEOF(tags) )
 542         s = tags[tag];
 543     else
 544         s.Printf(_T("unrecognized tag (%d)"), tag);
 545
 546     return s;
 547 }
 548
 549 static wxString KindString(wxDbgHelpDLL::DataKind kind)
 550 {
 551     static const wxChar *kinds[] =
 552     {
 553          _T("unknown"),
 554          _T("local"),
 555          _T("static local"),
 556          _T("param"),
 557          _T("object ptr"),
 558          _T("file static"),
 559          _T("global"),
 560          _T("member"),
 561          _T("static member"),
 562          _T("constant"),
 563     };
 564
 565     wxCOMPILE_TIME_ASSERT( WXSIZEOF(kinds) == wxDbgHelpDLL::DATA_MAX,
 566                                 DataKindStringMismatch );
 567
 568     wxString s;
 569     if ( kind < WXSIZEOF(kinds) )
 570         s = kinds[kind];
 571     else
 572         s.Printf(_T("unrecognized kind (%d)"), kind);
 573
 574     return s;
 575 }
 576
 577 static wxString UdtKindString(wxDbgHelpDLL::UdtKind kind)
 578 {
 579     static const wxChar *kinds[] =
 580     {
 581          _T("struct"),
 582          _T("class"),
 583          _T("union"),
 584     };
 585
 586     wxCOMPILE_TIME_ASSERT( WXSIZEOF(kinds) == wxDbgHelpDLL::UDT_MAX,
 587                                 UDTKindStringMismatch );
 588
 589     wxString s;
 590     if ( kind < WXSIZEOF(kinds) )
 591         s = kinds[kind];
 592     else
 593         s.Printf(_T("unrecognized UDT (%d)"), kind);
 594
 595     return s;
 596 }
 597
 598 static wxString TypeString(wxDbgHelpDLL::BasicType bt)
 599 {
 600     static const wxChar *types[] =
 601     {
 602         _T("no type"),
 603         _T("void"),
 604         _T("char"),
 605         _T("wchar"),
 606         _T(""),
 607         _T(""),
 608         _T("int"),
 609         _T("uint"),
 610         _T("float"),
 611         _T("bcd"),
 612         _T("bool"),
 613         _T(""),
 614         _T(""),
 615         _T("long"),
 616         _T("ulong"),
 617         _T(""),
 618         _T(""),
 619         _T(""),
 620         _T(""),
 621         _T(""),
 622         _T(""),
 623         _T(""),
 624         _T(""),
 625         _T(""),
 626         _T(""),
 627         _T("CURRENCY"),
 628         _T("DATE"),
 629         _T("VARIANT"),
 630         _T("complex"),
 631         _T("bit"),
 632         _T("BSTR"),
 633         _T("HRESULT"),
 634     };
 635
 636     wxCOMPILE_TIME_ASSERT( WXSIZEOF(types) == wxDbgHelpDLL::BASICTYPE_MAX,
 637                                 BasicTypeStringMismatch );
 638
 639     wxString s;
 640     if ( bt < WXSIZEOF(types) )
 641         s = types[bt];
 642
 643     if ( s.empty() )
 644         s.Printf(_T("unrecognized type (%d)"), bt);
 645
 646     return s;
 647 }
 648
 649 // this function is meant to be called from under debugger to see the
 650 // proprieties of the given type id
 651 extern "C" void DumpTI(ULONG ti)
 652 {
 653     SYMBOL_INFO sym = { sizeof(SYMBOL_INFO) };
 654     sym.ModBase = 0x400000; // it's a constant under Win32
 655     sym.TypeIndex = ti;
 656
 657     wxDbgHelpDLL::SymbolTag tag = wxDbgHelpDLL::SYMBOL_TAG_NULL;
 658     DoGetTypeInfo(&sym, TI_GET_SYMTAG, &tag);
 659     DoGetTypeInfo(&sym, TI_GET_TYPEID, &ti);
 660
 661     OutputDebugString(wxString::Format(_T("Type 0x%x: "), sym.TypeIndex));
 662     wxString name = wxDbgHelpDLL::GetSymbolName(&sym);
 663     if ( !name.empty() )
 664     {
 665         OutputDebugString(wxString::Format(_T("name=\"%s\", "), name.c_str()));
 666     }
 667
 668     DWORD nested;
 669     if ( !DoGetTypeInfo(&sym, TI_GET_NESTED, &nested) )
 670     {
 671         nested = FALSE;
 672     }
 673
 674     OutputDebugString(wxString::Format(_T("tag=%s%s"),
 675                       nested ? _T("nested ") : wxEmptyString,
 676                       TagString(tag).c_str()));
 677     if ( tag == wxDbgHelpDLL::SYMBOL_TAG_UDT )
 678     {
 679         wxDbgHelpDLL::UdtKind udtKind;
 680         if ( DoGetTypeInfo(&sym, TI_GET_UDTKIND, &udtKind) )
 681         {
 682             OutputDebugString(_T(" (") + UdtKindString(udtKind) + _T(')'));
 683         }
 684     }
 685
 686     wxDbgHelpDLL::DataKind kind = wxDbgHelpDLL::DATA_UNKNOWN;
 687     if ( DoGetTypeInfo(&sym, TI_GET_DATAKIND, &kind) )
 688     {
 689         OutputDebugString(wxString::Format(
 690             _T(", kind=%s"), KindString(kind).c_str()));
 691         if ( kind == wxDbgHelpDLL::DATA_MEMBER )
 692         {
 693             DWORD ofs = 0;
 694             if ( DoGetTypeInfo(&sym, TI_GET_OFFSET, &ofs) )
 695             {
 696                 OutputDebugString(wxString::Format(_T(" (ofs=0x%x)"), ofs));
 697             }
 698         }
 699     }
 700
 701     wxDbgHelpDLL::BasicType bt = GetBasicType(&sym);
 702     if ( bt )
 703     {
 704         OutputDebugString(wxString::Format(_T(", type=%s"),
 705                                 TypeString(bt).c_str()));
 706     }
 707
 708     if ( ti != sym.TypeIndex )
 709     {
 710         OutputDebugString(wxString::Format(_T(", next ti=0x%x"), ti));
 711     }
 712
 713     OutputDebugString(_T("\r\n"));
 714 }
 715
 716 #endif // NDEBUG
 717
 718 #endif // wxUSE_DBGHELP