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