1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "utilities/globalDefinitions.hpp"
  27 #include "symbolengine.hpp"
  28 #include "utilities/debug.hpp"
  29 #include "windbghelp.hpp"
  30 
  31 #include <windows.h>
  32 
  33 #include <imagehlp.h>
  34 #include <psapi.h>
  35 
  36 
  37 
  38 // This code may be invoked normally but also as part of error reporting
  39 // In the latter case, we may run under tight memory constraints (native oom)
  40 // or in a stack overflow situation or the C heap may be corrupted. We may
  41 // run very early before VM initialization or very late when C exit handlers
  42 // run. In all these cases, callstacks would still be nice, so lets be robust.
  43 //
  44 // We need a number of buffers - for the pdb search path, module handle
  45 // lists, for demangled symbols, etc.
  46 //
  47 // These buffers, while typically small, may need to be large for corner
  48 // cases (e.g. templatized C++ symbols, or many DLLs loaded). Where do we
  49 // allocate them?
  50 //
  51 // We may be in error handling for a stack overflow, so lets not put them on
  52 // the stack.
  53 //
  54 // Dynamically allocating them may fail if we are handling a native OOM. It
  55 // is also a bit dangerous, as the C heap may be corrupted already.
  56 //
  57 // That leaves pre-allocating them globally, which is safe and should always
  58 // work (if we synchronize access) but incurs an undesirable footprint for
  59 // non-error cases.
  60 //
  61 // We follow a two-way strategy: Allocate the buffers on the C heap in a
  62 // reasonable large size. Failing that, fall back to static preallocated
  63 // buffers. The size of the latter is large enough to handle common scenarios
  64 // but small enough not to drive up the footprint too much (several kb).
  65 //
  66 // We keep these buffers around once allocated, for subsequent requests. This
  67 // means that by running the initialization early at a safe time - before
  68 // any error happens - buffers can be pre-allocated. This increases the chance
  69 // of useful callstacks in error scenarios in exchange for a some cycles spent
  70 // at startup. This behavior can be controlled with -XX:+InitializeDbgHelpEarly
  71 // and is off by default.
  72 
  73 ///////
  74 
  75 // A simple buffer which attempts to allocate an optimal size but will
  76 // fall back to a static minimally sized array on allocation error.
  77 template <class T, int MINIMAL_CAPACITY, int OPTIMAL_CAPACITY>
  78 class SimpleBufferWithFallback {
  79   T _fallback_buffer[MINIMAL_CAPACITY];
  80   T* _p;
  81   int _capacity;
  82 
  83   // A sentinel at the end of the buffer to catch overflows.
  84   void imprint_sentinel() {
  85     assert(_p && _capacity > 0, "Buffer must be allocated");
  86     _p[_capacity - 1] = (T)'X';
  87     _capacity --;
  88   }
  89 
  90 public:
  91 
  92   SimpleBufferWithFallback<T, MINIMAL_CAPACITY, OPTIMAL_CAPACITY> ()
  93     : _p(NULL), _capacity(0)
  94   {}
  95 
  96   // Note: no destructor because these buffers should, once
  97   // allocated, live until process end.
  98   // ~SimpleBufferWithFallback()
  99 
 100   // Note: We use raw ::malloc/::free here instead of os::malloc()/os::free
 101   // to prevent circularities or secondary crashes during error reporting.
 102   virtual void initialize () {
 103     assert(_p == NULL && _capacity == 0, "Only call once.");
 104     const size_t bytes = OPTIMAL_CAPACITY * sizeof(T);
 105     T* q = (T*) ::malloc(bytes);
 106     if (q != NULL) {
 107       _p = q;
 108       _capacity = OPTIMAL_CAPACITY;
 109     } else {
 110       _p = _fallback_buffer;
 111       _capacity = (int)(sizeof(_fallback_buffer) / sizeof(T));
 112     }
 113     _p[0] = '\0';
 114     imprint_sentinel();
 115   }
 116 
 117   // We need a way to reset the buffer to fallback size for one special
 118   // case, where two buffers need to be of identical capacity.
 119   void reset_to_fallback_capacity() {
 120     if (_p != _fallback_buffer) {
 121       ::free(_p);
 122     }
 123     _p = _fallback_buffer;
 124     _capacity = (int)(sizeof(_fallback_buffer) / sizeof(T));
 125     _p[0] = '\0';
 126     imprint_sentinel();
 127   }
 128 
 129   T* ptr()                { return _p; }
 130   const T* ptr() const    { return _p; }
 131   int capacity() const    { return _capacity; }
 132 
 133 #ifdef ASSERT
 134   void check() const {
 135     assert(_p[_capacity] == (T)'X', "sentinel lost");
 136   }
 137 #else
 138   void check() const {}
 139 #endif
 140 
 141 };
 142 
 143 ////
 144 
 145 // ModuleHandleArray: a list holding module handles. Needs to be large enough
 146 // to hold one handle per loaded DLL.
 147 // Note: a standard OpenJDK loads normally ~30 libraries, including system
 148 // libraries, without third party libraries.
 149 
 150 typedef SimpleBufferWithFallback <HMODULE, 48, 512> ModuleHandleArrayBase;
 151 
 152 class ModuleHandleArray : public ModuleHandleArrayBase {
 153 
 154   int _num; // Number of handles in this array (may be < capacity).
 155 
 156 public:
 157 
 158   void initialize() {
 159     ModuleHandleArrayBase::initialize();
 160     _num = 0;
 161   }
 162 
 163   int num() const { return _num; }
 164   void set_num(int n) {
 165     assert(n <= capacity(), "Too large");
 166     _num = n;
 167   }
 168 
 169   // Compare with another list; returns true if all handles are equal (incl.
 170   // sort order)
 171   bool equals(const ModuleHandleArray& other) const {
 172     if (_num != other._num) {
 173       return false;
 174     }
 175     if (::memcmp(ptr(), other.ptr(), _num * sizeof(HMODULE)) != 0) {
 176       return false;
 177     }
 178     return true;
 179   }
 180 
 181   // Copy content from other list.
 182   void copy_content_from(ModuleHandleArray& other) {
 183     assert(capacity() == other.capacity(), "Different capacities.");
 184     memcpy(ptr(), other.ptr(), other._num * sizeof(HMODULE));
 185     _num = other._num;
 186   }
 187 
 188 };
 189 
 190 ////
 191 
 192 // PathBuffer: a buffer to hold and work with a pdb search PATH - a concatenation
 193 // of multiple directories separated by ';'.
 194 // A single directory name can be (NTFS) as long as 32K, but in reality is
 195 // seldom larger than the (historical) MAX_PATH of 260.
 196 
 197 #define MINIMUM_PDB_PATH_LENGTH  MAX_PATH * 4
 198 #define OPTIMAL_PDB_PATH_LENGTH  MAX_PATH * 64
 199 
 200 typedef SimpleBufferWithFallback<char, MINIMUM_PDB_PATH_LENGTH, OPTIMAL_PDB_PATH_LENGTH> PathBufferBase;
 201 
 202 class PathBuffer: public PathBufferBase {
 203 public:
 204 
 205   // Search PDB path for a directory. Search is case insensitive. Returns
 206   // true if directory was found in the path, false otherwise.
 207   bool contains_directory(const char* directory) {
 208     if (ptr() == NULL) {
 209       return false;
 210     }
 211     const size_t len = strlen(directory);
 212     if (len == 0) {
 213       return false;
 214     }
 215     char* p = ptr();
 216     for(;;) {
 217       char* q = strchr(p, ';');
 218       if (q != NULL) {
 219         if (len == (q - p)) {
 220           if (strnicmp(p, directory, len) == 0) {
 221             return true;
 222           }
 223         }
 224         p = q + 1;
 225       } else {
 226         // tail
 227         return stricmp(p, directory) == 0 ? true : false;
 228       }
 229     }
 230     return false;
 231   }
 232 
 233   // Appends the given directory to the path. Returns false if internal
 234   // buffer size was not sufficient.
 235   bool append_directory(const char* directory) {
 236     const size_t len = strlen(directory);
 237     if (len == 0) {
 238       return false;
 239     }
 240     char* p = ptr();
 241     const size_t len_now = strlen(p);
 242     const size_t needs_capacity = len_now + 1 + len + 1; // xxx;yy\0
 243     if (needs_capacity > (size_t)capacity()) {
 244       return false; // OOM
 245     }
 246     if (len_now > 0) { // Not the first path element.
 247       p += len_now;
 248       *p = ';';
 249       p ++;
 250     }
 251     strcpy(p, directory);
 252     return true;
 253   }
 254 
 255 };
 256 
 257 // A simple buffer to hold one single file name. A file name can be (NTFS) as
 258 // long as 32K, but in reality is seldom larger than MAX_PATH.
 259 typedef SimpleBufferWithFallback<char, MAX_PATH, 8 * K> FileNameBuffer;
 260 
 261 // A buffer to hold a C++ symbol. Usually small, but symbols may be larger for
 262 // templates.
 263 #define MINIMUM_SYMBOL_NAME_LEN 128
 264 #define OPTIMAL_SYMBOL_NAME_LEN 1024
 265 
 266 typedef SimpleBufferWithFallback<uint8_t,
 267         sizeof(IMAGEHLP_SYMBOL64) + MINIMUM_SYMBOL_NAME_LEN,
 268         sizeof(IMAGEHLP_SYMBOL64) + OPTIMAL_SYMBOL_NAME_LEN> SymbolBuffer;
 269 
 270 static struct {
 271 
 272   // Two buffers to hold lists of loaded modules. handles across invocations of
 273   // SymbolEngine::recalc_search_path().
 274   ModuleHandleArray loaded_modules;
 275   ModuleHandleArray last_loaded_modules;
 276   // Buffer to retrieve and assemble the pdb search path.
 277   PathBuffer search_path;
 278   // Buffer to retrieve directory names for loaded modules.
 279   FileNameBuffer dir_name;
 280   // Buffer to retrieve decoded symbol information (in SymbolEngine::decode)
 281   SymbolBuffer decode_buffer;
 282 
 283   void initialize() {
 284     search_path.initialize();
 285     dir_name.initialize();
 286     decode_buffer.initialize();
 287 
 288     loaded_modules.initialize();
 289     last_loaded_modules.initialize();
 290 
 291     // Note: both module lists must have the same capacity. If one allocation
 292     // did fail, let them both fall back to the fallback size.
 293     if (loaded_modules.capacity() != last_loaded_modules.capacity()) {
 294       loaded_modules.reset_to_fallback_capacity();
 295       last_loaded_modules.reset_to_fallback_capacity();
 296     }
 297 
 298     assert(search_path.capacity() > 0 && dir_name.capacity() > 0 &&
 299             decode_buffer.capacity() > 0 && loaded_modules.capacity() > 0 &&
 300             last_loaded_modules.capacity() > 0, "Init error.");
 301   }
 302 
 303 } g_buffers;
 304 
 305 
 306 // Scan the loaded modules.
 307 //
 308 // For each loaded module, add the directory it is located in to the pdb search
 309 // path, but avoid duplicates. Prior search path content is preserved.
 310 //
 311 // If p_search_path_was_updated is not NULL, points to a bool which, upon
 312 // successful return from the function, contains true if the search path
 313 // was updated, false if no update was needed because no new DLLs were
 314 // loaded or unloaded.
 315 //
 316 // Returns true for success, false for error.
 317 static bool recalc_search_path_locked(bool* p_search_path_was_updated) {
 318 
 319   if (p_search_path_was_updated) {
 320     *p_search_path_was_updated = false;
 321   }
 322 
 323   HANDLE hProcess = ::GetCurrentProcess();
 324 
 325   BOOL success = false;
 326 
 327   // 1) Retrieve current set search path.
 328   //    (PDB search path is a global setting and someone might have modified
 329   //     it, so take care not to remove directories, just to add our own).
 330 
 331   if (!WindowsDbgHelp::symGetSearchPath(hProcess, g_buffers.search_path.ptr(),
 332                                        (int)g_buffers.search_path.capacity())) {
 333     return false;
 334   }
 335   DEBUG_ONLY(g_buffers.search_path.check();)
 336 
 337   // 2) Retrieve list of modules handles of all currently loaded modules.
 338   DWORD bytes_needed = 0;
 339   const DWORD buffer_capacity_bytes = (DWORD)g_buffers.loaded_modules.capacity() * sizeof(HMODULE);
 340   success = ::EnumProcessModules(hProcess, g_buffers.loaded_modules.ptr(),
 341                                  buffer_capacity_bytes, &bytes_needed);
 342   DEBUG_ONLY(g_buffers.loaded_modules.check();)
 343 
 344   // Note: EnumProcessModules is sloppily defined in terms of whether a
 345   // too-small output buffer counts as error. Will it truncate but still
 346   // return TRUE? Nobody knows and the manpage is not telling. So we count
 347   // truncation it as error, disregarding the return value.
 348   if (!success || bytes_needed > buffer_capacity_bytes) {
 349     return false;
 350   } else {
 351     const int num_modules = bytes_needed / sizeof(HMODULE);
 352     g_buffers.loaded_modules.set_num(num_modules);
 353   }
 354 
 355   // Compare the list of module handles with the last list. If the lists are
 356   // identical, no additional dlls were loaded and we can stop.
 357   if (g_buffers.loaded_modules.equals(g_buffers.last_loaded_modules)) {
 358     return true;
 359   } else {
 360     // Remember the new set of module handles and continue.
 361     g_buffers.last_loaded_modules.copy_content_from(g_buffers.loaded_modules);
 362   }
 363 
 364   // 3) For each loaded module: retrieve directory from which it was loaded.
 365   //    Add directory to search path (but avoid duplicates).
 366 
 367   bool did_modify_searchpath = false;
 368 
 369   for (int i = 0; i < (int)g_buffers.loaded_modules.num(); i ++) {
 370 
 371     const HMODULE hMod = g_buffers.loaded_modules.ptr()[i];
 372     char* const filebuffer = g_buffers.dir_name.ptr();
 373     const int file_buffer_capacity = g_buffers.dir_name.capacity();
 374     const int len_returned = (int)::GetModuleFileName(hMod, filebuffer, (DWORD)file_buffer_capacity);
 375     DEBUG_ONLY(g_buffers.dir_name.check();)
 376     if (len_returned == 0) {
 377       // Error. This is suspicious - this may happen if a module has just been
 378       // unloaded concurrently after our call to EnumProcessModules and
 379       // GetModuleFileName, but probably just indicates a coding error.
 380       assert(false, "GetModuleFileName failed (%u)", ::GetLastError());
 381     } else if (len_returned == file_buffer_capacity) {
 382       // Truncation. Just skip this module and continue with the next module.
 383       continue;
 384     }
 385 
 386     // Cut file name part off.
 387     char* last_slash = ::strrchr(filebuffer, '\\');
 388     if (last_slash == NULL) {
 389       last_slash = ::strrchr(filebuffer, '/');
 390     }
 391     if (last_slash) {
 392       *last_slash = '\0';
 393     }
 394 
 395     // If this is already part of the search path, ignore it, otherwise
 396     // append to search path.
 397     if (!g_buffers.search_path.contains_directory(filebuffer)) {
 398       if (!g_buffers.search_path.append_directory(filebuffer)) {
 399         return false; // oom
 400       }
 401       DEBUG_ONLY(g_buffers.search_path.check();)
 402       did_modify_searchpath = true;
 403     }
 404 
 405   } // for each loaded module.
 406 
 407   // If we did not modify the search path, nothing further needs to be done.
 408   if (!did_modify_searchpath) {
 409     return true;
 410   }
 411 
 412   // Set the search path to its new value.
 413   if (!WindowsDbgHelp::symSetSearchPath(hProcess, g_buffers.search_path.ptr())) {
 414     return false;
 415   }
 416 
 417   if (p_search_path_was_updated) {
 418     *p_search_path_was_updated = true;
 419   }
 420 
 421   return true;
 422 
 423 }
 424 
 425 static bool demangle_locked(const char* symbol, char *buf, int buflen) {
 426 
 427   return WindowsDbgHelp::unDecorateSymbolName(symbol, buf, buflen, UNDNAME_COMPLETE) > 0;
 428 
 429 }
 430 
 431 static bool decode_locked(const void* addr, char* buf, int buflen, int* offset, bool do_demangle) {
 432 
 433   assert(g_buffers.decode_buffer.capacity() >= (sizeof(IMAGEHLP_SYMBOL64) + MINIMUM_SYMBOL_NAME_LEN),
 434          "Decode buffer too small.");
 435   assert(buf != NULL && buflen > 0 && offset != NULL, "invalid output buffer.");
 436 
 437   DWORD64 displacement;
 438   PIMAGEHLP_SYMBOL64 pSymbol = NULL;
 439   bool success = false;
 440 
 441   pSymbol = (PIMAGEHLP_SYMBOL64) g_buffers.decode_buffer.ptr();
 442   pSymbol->SizeOfStruct = sizeof(IMAGEHLP_SYMBOL64);
 443   pSymbol->MaxNameLength = (DWORD)(g_buffers.decode_buffer.capacity() - sizeof(IMAGEHLP_SYMBOL64) - 1);
 444 
 445   // It is unclear how SymGetSymFromAddr64 handles truncation. Experiments
 446   // show it will return TRUE but not zero terminate (which is a really bad
 447   // combination). Lets be super careful.
 448   ::memset(pSymbol->Name, 0, pSymbol->MaxNameLength); // To catch truncation.
 449 
 450   if (WindowsDbgHelp::symGetSymFromAddr64(::GetCurrentProcess(), (DWORD64)addr, &displacement, pSymbol)) {
 451     success = true;
 452     if (pSymbol->Name[pSymbol->MaxNameLength - 1] != '\0') {
 453       // Symbol was truncated. Do not attempt to demangle. Instead, zero terminate the
 454       // truncated string. We still return success - the truncated string may still
 455       // be usable for the caller.
 456       pSymbol->Name[pSymbol->MaxNameLength - 1] = '\0';
 457       do_demangle = false;
 458     }
 459 
 460     // Attempt to demangle.
 461     if (do_demangle && demangle_locked(pSymbol->Name, buf, buflen)) {
 462       // ok.
 463     } else {
 464       ::strncpy(buf, pSymbol->Name, buflen - 1);
 465     }
 466     buf[buflen - 1] = '\0';
 467 
 468     *offset = (int)displacement;
 469   }
 470 
 471   DEBUG_ONLY(g_buffers.decode_buffer.check();)
 472 
 473   return success;
 474 }
 475 
 476 static enum {
 477   state_uninitialized = 0,
 478   state_ready = 1,
 479   state_error = 2
 480 } g_state = state_uninitialized;
 481 
 482 static void initialize() {
 483 
 484   assert(g_state == state_uninitialized, "wrong sequence");
 485   g_state = state_error;
 486 
 487   // 1) Initialize buffers.
 488   g_buffers.initialize();
 489 
 490   // 1) Call SymInitialize
 491   HANDLE hProcess = ::GetCurrentProcess();
 492   WindowsDbgHelp::symSetOptions(SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_DEFERRED_LOADS |
 493                         SYMOPT_EXACT_SYMBOLS | SYMOPT_LOAD_LINES);
 494   if (!WindowsDbgHelp::symInitialize(hProcess, NULL, TRUE)) {
 495     return;
 496   }
 497 
 498   // Note: we ignore any errors from this point on. The symbol engine may be
 499   // usable enough.
 500   g_state = state_ready;
 501 
 502   (void)recalc_search_path_locked(NULL);
 503 
 504 }
 505 
 506 ///////////////////// External functions //////////////////////////
 507 
 508 // All outside facing functions are synchronized. Also, we run
 509 // initialization on first touch.
 510 
 511 static CRITICAL_SECTION g_cs;
 512 
 513 namespace { // Do not export.
 514   class SymbolEngineEntry {
 515    public:
 516     SymbolEngineEntry() {
 517       ::EnterCriticalSection(&g_cs);
 518       if (g_state == state_uninitialized) {
 519         initialize();
 520       }
 521     }
 522     ~SymbolEngineEntry() {
 523       ::LeaveCriticalSection(&g_cs);
 524     }
 525   };
 526 }
 527 
 528 // Called at DLL_PROCESS_ATTACH.
 529 void SymbolEngine::pre_initialize() {
 530   ::InitializeCriticalSection(&g_cs);
 531 }
 532 
 533 bool SymbolEngine::decode(const void* addr, char* buf, int buflen, int* offset, bool do_demangle) {
 534 
 535   assert(buf != NULL && buflen > 0 && offset != NULL, "Argument error");
 536   buf[0] = '\0';
 537   *offset = -1;
 538 
 539   if (addr == NULL) {
 540     return false;
 541   }
 542 
 543   SymbolEngineEntry entry_guard;
 544 
 545   // Try decoding the symbol once. If we fail, attempt to rebuild the
 546   // symbol search path - maybe the pc points to a dll whose pdb file is
 547   // outside our search path. Then do attempt the decode again.
 548   bool success = decode_locked(addr, buf, buflen, offset, do_demangle);
 549   if (!success) {
 550     bool did_update_search_path = false;
 551     if (recalc_search_path_locked(&did_update_search_path)) {
 552       if (did_update_search_path) {
 553         success = decode_locked(addr, buf, buflen, offset, do_demangle);
 554       }
 555     }
 556   }
 557 
 558   return success;
 559 
 560 }
 561 
 562 bool SymbolEngine::demangle(const char* symbol, char *buf, int buflen) {
 563 
 564   SymbolEngineEntry entry_guard;
 565 
 566   return demangle_locked(symbol, buf, buflen);
 567 
 568 }
 569 
 570 bool SymbolEngine::recalc_search_path(bool* p_search_path_was_updated) {
 571 
 572   SymbolEngineEntry entry_guard;
 573 
 574   return recalc_search_path_locked(p_search_path_was_updated);
 575 
 576 }
 577 
 578 bool SymbolEngine::get_source_info(const void* addr, char* buf, size_t buflen,
 579                                    int* line_no)
 580 {
 581   assert(buf != NULL && buflen > 0 && line_no != NULL, "Argument error");
 582   buf[0] = '\0';
 583   *line_no = -1;
 584 
 585   if (addr == NULL) {
 586     return false;
 587   }
 588 
 589   SymbolEngineEntry entry_guard;
 590 
 591   IMAGEHLP_LINE64 lineinfo;
 592   memset(&lineinfo, 0, sizeof(lineinfo));
 593   lineinfo.SizeOfStruct = sizeof(lineinfo);
 594   DWORD displacement;
 595   if (WindowsDbgHelp::symGetLineFromAddr64(::GetCurrentProcess(), (DWORD64)addr,
 596                                            &displacement, &lineinfo)) {
 597     if (buf != NULL && buflen > 0 && lineinfo.FileName != NULL) {
 598       // We only return the file name, not the whole path.
 599       char* p = lineinfo.FileName;
 600       char* q = strrchr(lineinfo.FileName, '\\');
 601       if (q) {
 602         p = q + 1;
 603       }
 604       ::strncpy(buf, p, buflen - 1);
 605       buf[buflen - 1] = '\0';
 606     }
 607     if (line_no != 0) {
 608       *line_no = lineinfo.LineNumber;
 609     }
 610     return true;
 611   }
 612   return false;
 613 }
 614 
 615 // Print one liner describing state (if library loaded, which functions are
 616 // missing - if any, and the dbhelp API version)
 617 void SymbolEngine::print_state_on(outputStream* st) {
 618 
 619   SymbolEngineEntry entry_guard;
 620 
 621   st->print("symbol engine: ");
 622 
 623   if (g_state == state_uninitialized) {
 624     st->print("uninitialized.");
 625   } else if (g_state == state_error) {
 626     st->print("initialization error.");
 627   } else {
 628     st->print("initialized successfully");
 629     st->print(" - sym options: 0x%X", WindowsDbgHelp::symGetOptions());
 630     st->print(" - pdb path: ");
 631     if (WindowsDbgHelp::symGetSearchPath(::GetCurrentProcess(),
 632                                           g_buffers.search_path.ptr(),
 633                                           (int)g_buffers.search_path.capacity())) {
 634       st->print_raw(g_buffers.search_path.ptr());
 635     } else {
 636       st->print_raw("(cannot be retrieved)");
 637     }
 638   }
 639   st->cr();
 640 
 641 }