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