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
 402         // take care to use c_str() here as otherwise we might hit an assert in
 403         // wxString code if it is currently locked for writing (i.e. we're
 404         // between GetWriteBuf() and UngetWriteBuf() calls)
 405         s << _T("(\"") << ps->c_str() << _T(")\"");
 406     }
 407     else // any other UDT
 408 #endif // !wxUSE_STL
 409     {
 410         // Determine how many children this type has.
 411         DWORD dwChildrenCount = 0;
 412         DoGetTypeInfo(pSym, TI_GET_CHILDRENCOUNT, &dwChildrenCount);
 413
 414         // Prepare to get an array of "TypeIds", representing each of the children.
 415         TI_FINDCHILDREN_PARAMS *children = (TI_FINDCHILDREN_PARAMS *)
 416             malloc(sizeof(TI_FINDCHILDREN_PARAMS) +
 417                         (dwChildrenCount - 1)*sizeof(ULONG));
 418         if ( !children )
 419             return s;
 420
 421         children->Count = dwChildrenCount;
 422         children->Start = 0;
 423
 424         // Get the array of TypeIds, one for each child type
 425         if ( !DoGetTypeInfo(pSym, TI_FINDCHILDREN, children) )
 426         {
 427             free(children);
 428             return s;
 429         }
 430
 431         s << _T(" {\n");
 432
 433         // Iterate through all children
 434         SYMBOL_INFO sym;
 435         wxZeroMemory(sym);
 436         sym.ModBase = pSym->ModBase;
 437         for ( unsigned i = 0; i < dwChildrenCount; i++ )
 438         {
 439             sym.TypeIndex = children->ChildId[i];
 440
 441             // children here are in lexicographic sense, i.e. we get all our nested
 442             // classes and not only our member fields, but we can't get the values
 443             // for the members of the nested classes, of course!
 444             DWORD nested;
 445             if ( DoGetTypeInfo(&sym, TI_GET_NESTED, &nested) && nested )
 446                 continue;
 447
 448             // avoid infinite recursion: this does seem to happen sometimes with
 449             // complex typedefs...
 450             if ( sym.TypeIndex == pSym->TypeIndex )
 451                 continue;
 452
 453             s += DumpField(&sym, pVariable, level + 1);
 454         }
 455
 456         free(children);
 457
 458         s << wxString(_T('\t'), level + 1) << _T('}');
 459     }
 460
 461     return s;
 462 }
 463
 464 /* static */
 465 wxDbgHelpDLL::SymbolTag
 466 wxDbgHelpDLL::DereferenceSymbol(PSYMBOL_INFO pSym, void **ppData)
 467 {
 468     SymbolTag tag = SYMBOL_TAG_NULL;
 469     for ( ;; )
 470     {
 471         if ( !DoGetTypeInfo(pSym, TI_GET_SYMTAG, &tag) )
 472             break;
 473
 474         if ( tag != SYMBOL_TAG_POINTER_TYPE )
 475             break;
 476
 477         ULONG tiNew;
 478         if ( !DoGetTypeInfo(pSym, TI_GET_TYPEID, &tiNew) ||
 479                 tiNew == pSym->TypeIndex )
 480             break;
 481
 482         pSym->TypeIndex = tiNew;
 483
 484         // remove one level of indirection except for the char strings: we want
 485         // to dump "char *" and not a single "char" for them
 486         if ( ppData && *ppData && GetBasicType(pSym) != BASICTYPE_CHAR )
 487         {
 488             DWORD_PTR *pData = (DWORD_PTR *)*ppData;
 489
 490             if ( ::IsBadReadPtr(pData, sizeof(DWORD_PTR *)) )
 491             {
 492                 break;
 493             }
 494
 495             *ppData = (void *)*pData;
 496         }
 497     }
 498
 499     return tag;
 500 }
 501
 502 /* static */ wxString
 503 wxDbgHelpDLL::DumpSymbol(PSYMBOL_INFO pSym, void *pVariable)
 504 {
 505     wxString s;
 506     SYMBOL_INFO symDeref = *pSym;
 507     switch ( DereferenceSymbol(&symDeref, &pVariable) )
 508     {
 509         case SYMBOL_TAG_UDT:
 510             // show UDT recursively
 511             s = DumpUDT(&symDeref, pVariable);
 512             break;
 513
 514         case SYMBOL_TAG_BASE_TYPE:
 515             // variable of simple type, show directly
 516             BasicType bt = GetBasicType(&symDeref);
 517             if ( bt )
 518             {
 519                 s = DumpBaseType(bt, pSym->Size, pVariable);
 520             }
 521             break;
 522     }
 523
 524     return s;
 525 }
 526
 527 // ----------------------------------------------------------------------------
 528 // debugging helpers
 529 // ----------------------------------------------------------------------------
 530
 531 // this code is very useful when debugging debughlp.dll-related code but
 532 // probably not worth having compiled in normally, please do not remove it!
 533 #if 0 // ndef NDEBUG
 534
 535 static wxString TagString(wxDbgHelpDLL::SymbolTag tag)
 536 {
 537     static const wxChar *tags[] =
 538     {
 539         _T("null"),
 540         _T("exe"),
 541         _T("compiland"),
 542         _T("compiland details"),
 543         _T("compiland env"),
 544         _T("function"),
 545         _T("block"),
 546         _T("data"),
 547         _T("annotation"),
 548         _T("label"),
 549         _T("public symbol"),
 550         _T("udt"),
 551         _T("enum"),
 552         _T("function type"),
 553         _T("pointer type"),
 554         _T("array type"),
 555         _T("base type"),
 556         _T("typedef"),
 557         _T("base class"),
 558         _T("friend"),
 559         _T("function arg type"),
 560         _T("func debug start"),
 561         _T("func debug end"),
 562         _T("using namespace"),
 563         _T("vtable shape"),
 564         _T("vtable"),
 565         _T("custom"),
 566         _T("thunk"),
 567         _T("custom type"),
 568         _T("managed type"),
 569         _T("dimension"),
 570     };
 571
 572     wxCOMPILE_TIME_ASSERT( WXSIZEOF(tags) == wxDbgHelpDLL::SYMBOL_TAG_MAX,
 573                                 SymbolTagStringMismatch );
 574
 575     wxString s;
 576     if ( tag < WXSIZEOF(tags) )
 577         s = tags[tag];
 578     else
 579         s.Printf(_T("unrecognized tag (%d)"), tag);
 580
 581     return s;
 582 }
 583
 584 static wxString KindString(wxDbgHelpDLL::DataKind kind)
 585 {
 586     static const wxChar *kinds[] =
 587     {
 588          _T("unknown"),
 589          _T("local"),
 590          _T("static local"),
 591          _T("param"),
 592          _T("object ptr"),
 593          _T("file static"),
 594          _T("global"),
 595          _T("member"),
 596          _T("static member"),
 597          _T("constant"),
 598     };
 599
 600     wxCOMPILE_TIME_ASSERT( WXSIZEOF(kinds) == wxDbgHelpDLL::DATA_MAX,
 601                                 DataKindStringMismatch );
 602
 603     wxString s;
 604     if ( kind < WXSIZEOF(kinds) )
 605         s = kinds[kind];
 606     else
 607         s.Printf(_T("unrecognized kind (%d)"), kind);
 608
 609     return s;
 610 }
 611
 612 static wxString UdtKindString(wxDbgHelpDLL::UdtKind kind)
 613 {
 614     static const wxChar *kinds[] =
 615     {
 616          _T("struct"),
 617          _T("class"),
 618          _T("union"),
 619     };
 620
 621     wxCOMPILE_TIME_ASSERT( WXSIZEOF(kinds) == wxDbgHelpDLL::UDT_MAX,
 622                                 UDTKindStringMismatch );
 623
 624     wxString s;
 625     if ( kind < WXSIZEOF(kinds) )
 626         s = kinds[kind];
 627     else
 628         s.Printf(_T("unrecognized UDT (%d)"), kind);
 629
 630     return s;
 631 }
 632
 633 static wxString TypeString(wxDbgHelpDLL::BasicType bt)
 634 {
 635     static const wxChar *types[] =
 636     {
 637         _T("no type"),
 638         _T("void"),
 639         _T("char"),
 640         _T("wchar"),
 641         _T(""),
 642         _T(""),
 643         _T("int"),
 644         _T("uint"),
 645         _T("float"),
 646         _T("bcd"),
 647         _T("bool"),
 648         _T(""),
 649         _T(""),
 650         _T("long"),
 651         _T("ulong"),
 652         _T(""),
 653         _T(""),
 654         _T(""),
 655         _T(""),
 656         _T(""),
 657         _T(""),
 658         _T(""),
 659         _T(""),
 660         _T(""),
 661         _T(""),
 662         _T("CURRENCY"),
 663         _T("DATE"),
 664         _T("VARIANT"),
 665         _T("complex"),
 666         _T("bit"),
 667         _T("BSTR"),
 668         _T("HRESULT"),
 669     };
 670
 671     wxCOMPILE_TIME_ASSERT( WXSIZEOF(types) == wxDbgHelpDLL::BASICTYPE_MAX,
 672                                 BasicTypeStringMismatch );
 673
 674     wxString s;
 675     if ( bt < WXSIZEOF(types) )
 676         s = types[bt];
 677
 678     if ( s.empty() )
 679         s.Printf(_T("unrecognized type (%d)"), bt);
 680
 681     return s;
 682 }
 683
 684 // this function is meant to be called from under debugger to see the
 685 // proprieties of the given type id
 686 extern "C" void DumpTI(ULONG ti)
 687 {
 688     SYMBOL_INFO sym = { sizeof(SYMBOL_INFO) };
 689     sym.ModBase = 0x400000; // it's a constant under Win32
 690     sym.TypeIndex = ti;
 691
 692     wxDbgHelpDLL::SymbolTag tag = wxDbgHelpDLL::SYMBOL_TAG_NULL;
 693     DoGetTypeInfo(&sym, TI_GET_SYMTAG, &tag);
 694     DoGetTypeInfo(&sym, TI_GET_TYPEID, &ti);
 695
 696     OutputDebugString(wxString::Format(_T("Type 0x%x: "), sym.TypeIndex));
 697     wxString name = wxDbgHelpDLL::GetSymbolName(&sym);
 698     if ( !name.empty() )
 699     {
 700         OutputDebugString(wxString::Format(_T("name=\"%s\", "), name.c_str()));
 701     }
 702
 703     DWORD nested;
 704     if ( !DoGetTypeInfo(&sym, TI_GET_NESTED, &nested) )
 705     {
 706         nested = FALSE;
 707     }
 708
 709     OutputDebugString(wxString::Format(_T("tag=%s%s"),
 710                       nested ? _T("nested ") : wxEmptyString,
 711                       TagString(tag).c_str()));
 712     if ( tag == wxDbgHelpDLL::SYMBOL_TAG_UDT )
 713     {
 714         wxDbgHelpDLL::UdtKind udtKind;
 715         if ( DoGetTypeInfo(&sym, TI_GET_UDTKIND, &udtKind) )
 716         {
 717             OutputDebugString(_T(" (") + UdtKindString(udtKind) + _T(')'));
 718         }
 719     }
 720
 721     wxDbgHelpDLL::DataKind kind = wxDbgHelpDLL::DATA_UNKNOWN;
 722     if ( DoGetTypeInfo(&sym, TI_GET_DATAKIND, &kind) )
 723     {
 724         OutputDebugString(wxString::Format(
 725             _T(", kind=%s"), KindString(kind).c_str()));
 726         if ( kind == wxDbgHelpDLL::DATA_MEMBER )
 727         {
 728             DWORD ofs = 0;
 729             if ( DoGetTypeInfo(&sym, TI_GET_OFFSET, &ofs) )
 730             {
 731                 OutputDebugString(wxString::Format(_T(" (ofs=0x%x)"), ofs));
 732             }
 733         }
 734     }
 735
 736     wxDbgHelpDLL::BasicType bt = GetBasicType(&sym);
 737     if ( bt )
 738     {
 739         OutputDebugString(wxString::Format(_T(", type=%s"),
 740                                 TypeString(bt).c_str()));
 741     }
 742
 743     if ( ti != sym.TypeIndex )
 744     {
 745         OutputDebugString(wxString::Format(_T(", next ti=0x%x"), ti));
 746     }
 747
 748     OutputDebugString(_T("\r\n"));
 749 }
 750
 751 #endif // NDEBUG
 752
 753 #endif // wxUSE_DBGHELP