src/hotspot/os/windows/windbghelp.cpp - platform/libcore - Git at Google

 /*
  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */

 #include "precompiled.hpp"
 #include "utilities/ostream.hpp"
 #include "windbghelp.hpp"

 #include <windows.h>

 typedef DWORD (WINAPI *pfn_SymSetOptions)(DWORD);
 typedef DWORD (WINAPI *pfn_SymGetOptions)(void);
 typedef BOOL  (WINAPI *pfn_SymInitialize)(HANDLE, PCTSTR, BOOL);
 typedef BOOL  (WINAPI *pfn_SymGetSymFromAddr64)(HANDLE, DWORD64, PDWORD64, PIMAGEHLP_SYMBOL64);
 typedef DWORD (WINAPI *pfn_UnDecorateSymbolName)(const char*, char*, DWORD, DWORD);
 typedef BOOL  (WINAPI *pfn_SymSetSearchPath)(HANDLE, PCTSTR);
 typedef BOOL  (WINAPI *pfn_SymGetSearchPath)(HANDLE, PTSTR, int);
 typedef BOOL  (WINAPI *pfn_StackWalk64)(DWORD MachineType,
                                         HANDLE hProcess,
                                         HANDLE hThread,
                                         LPSTACKFRAME64 StackFrame,
                                         PVOID ContextRecord,
                                         PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
                                         PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
                                         PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
                                         PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
 typedef PVOID (WINAPI *pfn_SymFunctionTableAccess64)(HANDLE hProcess, DWORD64 AddrBase);
 typedef DWORD64 (WINAPI *pfn_SymGetModuleBase64)(HANDLE hProcess, DWORD64 dwAddr);
 typedef BOOL (WINAPI *pfn_MiniDumpWriteDump) (HANDLE hProcess, DWORD ProcessId, HANDLE hFile,
                                               MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
                                               PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
                                               PMINIDUMP_CALLBACK_INFORMATION    CallbackParam);
 typedef BOOL (WINAPI *pfn_SymGetLineFromAddr64) (HANDLE hProcess, DWORD64 dwAddr,
                                                  PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line);
 typedef LPAPI_VERSION (WINAPI *pfn_ImagehlpApiVersion)(void);

 // Add functions as needed.
 #define FOR_ALL_FUNCTIONS(DO) \
  DO(ImagehlpApiVersion) \
  DO(SymGetOptions) \
  DO(SymSetOptions) \
  DO(SymInitialize) \
  DO(SymGetSymFromAddr64) \
  DO(UnDecorateSymbolName) \
  DO(SymSetSearchPath) \
  DO(SymGetSearchPath) \
  DO(StackWalk64) \
  DO(SymFunctionTableAccess64) \
  DO(SymGetModuleBase64) \
  DO(MiniDumpWriteDump) \
  DO(SymGetLineFromAddr64)


 #define DECLARE_FUNCTION_POINTER(functionname) \
 static pfn_##functionname g_pfn_##functionname;

 FOR_ALL_FUNCTIONS(DECLARE_FUNCTION_POINTER)


 static HMODULE g_dll_handle = NULL;
 static DWORD g_dll_load_error = 0;
 static API_VERSION g_version = { 0, 0, 0, 0 };

 static enum {
   state_uninitialized = 0,
   state_ready = 1,
   state_error = 2
 } g_state = state_uninitialized;

 static void initialize() {

   assert(g_state == state_uninitialized, "wrong sequence");
   g_state = state_error;

   g_dll_handle = ::LoadLibrary("DBGHELP.DLL");
   if (g_dll_handle == NULL) {
     g_dll_load_error = ::GetLastError();
   } else {
     // Note: We loaded the DLL successfully. From here on we count
     // initialization as success. We still may fail to load all of the
     // desired function pointers successfully, but DLL may still be usable
     // enough for our purposes.
     g_state = state_ready;

 #define DO_RESOLVE(functionname) \
       g_pfn_##functionname = (pfn_##functionname) ::GetProcAddress(g_dll_handle, #functionname);

     FOR_ALL_FUNCTIONS(DO_RESOLVE)

     // Retrieve version information.
     if (g_pfn_ImagehlpApiVersion) {
       const API_VERSION* p = g_pfn_ImagehlpApiVersion();
       memcpy(&g_version, p, sizeof(API_VERSION));
     }
   }

 }


 ///////////////////// External functions //////////////////////////

 // All outside facing functions are synchronized. Also, we run
 // initialization on first touch.

 static CRITICAL_SECTION g_cs;

 namespace { // Do not export.
   class WindowsDbgHelpEntry {
    public:
     WindowsDbgHelpEntry() {
       ::EnterCriticalSection(&g_cs);
       if (g_state == state_uninitialized) {
         initialize();
       }
     }
     ~WindowsDbgHelpEntry() {
       ::LeaveCriticalSection(&g_cs);
     }
   };
 }

 // Called at DLL_PROCESS_ATTACH.
 void WindowsDbgHelp::pre_initialize() {
   ::InitializeCriticalSection(&g_cs);
 }

 DWORD WindowsDbgHelp::symSetOptions(DWORD arg) {
   WindowsDbgHelpEntry entry_guard;
   if (g_pfn_SymSetOptions != NULL) {
     return g_pfn_SymSetOptions(arg);
   }
   return 0;
 }

 DWORD WindowsDbgHelp::symGetOptions(void) {
   WindowsDbgHelpEntry entry_guard;
   if (g_pfn_SymGetOptions != NULL) {
     return g_pfn_SymGetOptions();
   }
   return 0;
 }

 BOOL WindowsDbgHelp::symInitialize(HANDLE hProcess, PCTSTR UserSearchPath, BOOL fInvadeProcess) {
   WindowsDbgHelpEntry entry_guard;
   if (g_pfn_SymInitialize != NULL) {
     return g_pfn_SymInitialize(hProcess, UserSearchPath, fInvadeProcess);
   }
   return FALSE;
 }

 BOOL WindowsDbgHelp::symGetSymFromAddr64(HANDLE hProcess, DWORD64 the_address,
                                          PDWORD64 Displacement, PIMAGEHLP_SYMBOL64 Symbol) {
   WindowsDbgHelpEntry entry_guard;
   if (g_pfn_SymGetSymFromAddr64 != NULL) {
     return g_pfn_SymGetSymFromAddr64(hProcess, the_address, Displacement, Symbol);
   }
   return FALSE;
 }

 DWORD WindowsDbgHelp::unDecorateSymbolName(const char* DecoratedName, char* UnDecoratedName,
                                            DWORD UndecoratedLength, DWORD Flags) {
   WindowsDbgHelpEntry entry_guard;
   if (g_pfn_UnDecorateSymbolName != NULL) {
     return g_pfn_UnDecorateSymbolName(DecoratedName, UnDecoratedName, UndecoratedLength, Flags);
   }
   if (UnDecoratedName != NULL && UndecoratedLength > 0) {
     UnDecoratedName[0] = '\0';
   }
   return 0;
 }

 BOOL WindowsDbgHelp::symSetSearchPath(HANDLE hProcess, PCTSTR SearchPath) {
   WindowsDbgHelpEntry entry_guard;
   if (g_pfn_SymSetSearchPath != NULL) {
     return g_pfn_SymSetSearchPath(hProcess, SearchPath);
   }
   return FALSE;
 }

 BOOL WindowsDbgHelp::symGetSearchPath(HANDLE hProcess, PTSTR SearchPath, int SearchPathLength) {
   WindowsDbgHelpEntry entry_guard;
   if (g_pfn_SymGetSearchPath != NULL) {
     return g_pfn_SymGetSearchPath(hProcess, SearchPath, SearchPathLength);
   }
   return FALSE;
 }

 BOOL WindowsDbgHelp::stackWalk64(DWORD MachineType,
                                  HANDLE hProcess,
                                  HANDLE hThread,
                                  LPSTACKFRAME64 StackFrame,
                                  PVOID ContextRecord) {
   WindowsDbgHelpEntry entry_guard;
   if (g_pfn_StackWalk64 != NULL) {
     return g_pfn_StackWalk64(MachineType, hProcess, hThread, StackFrame,
                              ContextRecord,
                              NULL, // ReadMemoryRoutine
                              g_pfn_SymFunctionTableAccess64, // FunctionTableAccessRoutine,
                              g_pfn_SymGetModuleBase64, // GetModuleBaseRoutine
                              NULL // TranslateAddressRoutine
                              );
   }
   return FALSE;
 }

 PVOID WindowsDbgHelp::symFunctionTableAccess64(HANDLE hProcess, DWORD64 AddrBase) {
   WindowsDbgHelpEntry entry_guard;
   if (g_pfn_SymFunctionTableAccess64 != NULL) {
     return g_pfn_SymFunctionTableAccess64(hProcess, AddrBase);
   }
   return NULL;
 }

 DWORD64 WindowsDbgHelp::symGetModuleBase64(HANDLE hProcess, DWORD64 dwAddr) {
   WindowsDbgHelpEntry entry_guard;
   if (g_pfn_SymGetModuleBase64 != NULL) {
     return g_pfn_SymGetModuleBase64(hProcess, dwAddr);
   }
   return 0;
 }

 BOOL WindowsDbgHelp::miniDumpWriteDump(HANDLE hProcess, DWORD ProcessId, HANDLE hFile,
                                        MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
                                        PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
                                        PMINIDUMP_CALLBACK_INFORMATION CallbackParam) {
   WindowsDbgHelpEntry entry_guard;
   if (g_pfn_MiniDumpWriteDump != NULL) {
     return g_pfn_MiniDumpWriteDump(hProcess, ProcessId, hFile, DumpType,
                                    ExceptionParam, UserStreamParam, CallbackParam);
   }
   return FALSE;
 }

 BOOL WindowsDbgHelp::symGetLineFromAddr64(HANDLE hProcess, DWORD64 dwAddr,
                           PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line) {
   WindowsDbgHelpEntry entry_guard;
   if (g_pfn_SymGetLineFromAddr64 != NULL) {
     return g_pfn_SymGetLineFromAddr64(hProcess, dwAddr, pdwDisplacement, Line);
   }
   return FALSE;
 }

 // Print one liner describing state (if library loaded, which functions are
 // missing - if any, and the dbhelp API version)
 void WindowsDbgHelp::print_state_on(outputStream* st) {
   // Note: We should not lock while printing, but this should be
   // safe to do without lock anyway.
   st->print("dbghelp: ");

   if (g_state == state_uninitialized) {
     st->print("uninitialized.");
   } else if (g_state == state_error) {
     st->print("loading error: %u", g_dll_load_error);
   } else {
     st->print("loaded successfully ");

     // We may want to print dll file name here - which may be interesting for
     // cases where more than one version exists on the system, e.g. with a
     // debugging sdk separately installed. But we get the file name in the DLL
     // section of the hs-err file too, so this may be redundant.

     // Print version.
     st->print("- version: %u.%u.%u",
               g_version.MajorVersion, g_version.MinorVersion, g_version.Revision);

     // Print any functions which failed to load.
     int num_missing = 0;
     st->print(" - missing functions: ");

     #define CHECK_AND_PRINT_IF_NULL(functionname) \
     if (g_pfn_##functionname == NULL) { \
       st->print("%s" #functionname, ((num_missing > 0) ? ", " : "")); \
       num_missing ++; \
     }

     FOR_ALL_FUNCTIONS(CHECK_AND_PRINT_IF_NULL)

     if (num_missing == 0) {
       st->print("none");
     }
   }
   st->cr();
 }
	/*
	* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*
	*/

	#include "precompiled.hpp"
	#include "utilities/ostream.hpp"
	#include "windbghelp.hpp"

	#include <windows.h>

	typedef DWORD (WINAPI *pfn_SymSetOptions)(DWORD);
	typedef DWORD (WINAPI *pfn_SymGetOptions)(void);
	typedef BOOL (WINAPI *pfn_SymInitialize)(HANDLE, PCTSTR, BOOL);
	typedef BOOL (WINAPI *pfn_SymGetSymFromAddr64)(HANDLE, DWORD64, PDWORD64, PIMAGEHLP_SYMBOL64);
	typedef DWORD (WINAPI pfn_UnDecorateSymbolName)(const char, char*, DWORD, DWORD);
	typedef BOOL (WINAPI *pfn_SymSetSearchPath)(HANDLE, PCTSTR);
	typedef BOOL (WINAPI *pfn_SymGetSearchPath)(HANDLE, PTSTR, int);
	typedef BOOL (WINAPI *pfn_StackWalk64)(DWORD MachineType,
	HANDLE hProcess,
	HANDLE hThread,
	LPSTACKFRAME64 StackFrame,
	PVOID ContextRecord,
	PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,
	PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,
	PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,
	PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress);
	typedef PVOID (WINAPI *pfn_SymFunctionTableAccess64)(HANDLE hProcess, DWORD64 AddrBase);
	typedef DWORD64 (WINAPI *pfn_SymGetModuleBase64)(HANDLE hProcess, DWORD64 dwAddr);
	typedef BOOL (WINAPI *pfn_MiniDumpWriteDump) (HANDLE hProcess, DWORD ProcessId, HANDLE hFile,
	MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
	PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
	PMINIDUMP_CALLBACK_INFORMATION CallbackParam);
	typedef BOOL (WINAPI *pfn_SymGetLineFromAddr64) (HANDLE hProcess, DWORD64 dwAddr,
	PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line);
	typedef LPAPI_VERSION (WINAPI *pfn_ImagehlpApiVersion)(void);

	// Add functions as needed.
	#define FOR_ALL_FUNCTIONS(DO) \
	DO(ImagehlpApiVersion) \
	DO(SymGetOptions) \
	DO(SymSetOptions) \
	DO(SymInitialize) \
	DO(SymGetSymFromAddr64) \
	DO(UnDecorateSymbolName) \
	DO(SymSetSearchPath) \
	DO(SymGetSearchPath) \
	DO(StackWalk64) \
	DO(SymFunctionTableAccess64) \
	DO(SymGetModuleBase64) \
	DO(MiniDumpWriteDump) \
	DO(SymGetLineFromAddr64)


	#define DECLARE_FUNCTION_POINTER(functionname) \
	static pfn_##functionname g_pfn_##functionname;

	FOR_ALL_FUNCTIONS(DECLARE_FUNCTION_POINTER)


	static HMODULE g_dll_handle = NULL;
	static DWORD g_dll_load_error = 0;
	static API_VERSION g_version = { 0, 0, 0, 0 };

	static enum {
	state_uninitialized = 0,
	state_ready = 1,
	state_error = 2
	} g_state = state_uninitialized;

	static void initialize() {

	assert(g_state == state_uninitialized, "wrong sequence");
	g_state = state_error;

	g_dll_handle = ::LoadLibrary("DBGHELP.DLL");
	if (g_dll_handle == NULL) {
	g_dll_load_error = ::GetLastError();
	} else {
	// Note: We loaded the DLL successfully. From here on we count
	// initialization as success. We still may fail to load all of the
	// desired function pointers successfully, but DLL may still be usable
	// enough for our purposes.
	g_state = state_ready;

	#define DO_RESOLVE(functionname) \
	g_pfn_##functionname = (pfn_##functionname) ::GetProcAddress(g_dll_handle, #functionname);

	FOR_ALL_FUNCTIONS(DO_RESOLVE)

	// Retrieve version information.
	if (g_pfn_ImagehlpApiVersion) {
	const API_VERSION* p = g_pfn_ImagehlpApiVersion();
	memcpy(&g_version, p, sizeof(API_VERSION));
	}
	}

	}


	///////////////////// External functions //////////////////////////

	// All outside facing functions are synchronized. Also, we run
	// initialization on first touch.

	static CRITICAL_SECTION g_cs;

	namespace { // Do not export.
	class WindowsDbgHelpEntry {
	public:
	WindowsDbgHelpEntry() {
	::EnterCriticalSection(&g_cs);
	if (g_state == state_uninitialized) {
	initialize();
	}
	}
	~WindowsDbgHelpEntry() {
	::LeaveCriticalSection(&g_cs);
	}
	};
	}

	// Called at DLL_PROCESS_ATTACH.
	void WindowsDbgHelp::pre_initialize() {
	::InitializeCriticalSection(&g_cs);
	}

	DWORD WindowsDbgHelp::symSetOptions(DWORD arg) {
	WindowsDbgHelpEntry entry_guard;
	if (g_pfn_SymSetOptions != NULL) {
	return g_pfn_SymSetOptions(arg);
	}
	return 0;
	}

	DWORD WindowsDbgHelp::symGetOptions(void) {
	WindowsDbgHelpEntry entry_guard;
	if (g_pfn_SymGetOptions != NULL) {
	return g_pfn_SymGetOptions();
	}
	return 0;
	}

	BOOL WindowsDbgHelp::symInitialize(HANDLE hProcess, PCTSTR UserSearchPath, BOOL fInvadeProcess) {
	WindowsDbgHelpEntry entry_guard;
	if (g_pfn_SymInitialize != NULL) {
	return g_pfn_SymInitialize(hProcess, UserSearchPath, fInvadeProcess);
	}
	return FALSE;
	}

	BOOL WindowsDbgHelp::symGetSymFromAddr64(HANDLE hProcess, DWORD64 the_address,
	PDWORD64 Displacement, PIMAGEHLP_SYMBOL64 Symbol) {
	WindowsDbgHelpEntry entry_guard;
	if (g_pfn_SymGetSymFromAddr64 != NULL) {
	return g_pfn_SymGetSymFromAddr64(hProcess, the_address, Displacement, Symbol);
	}
	return FALSE;
	}

	DWORD WindowsDbgHelp::unDecorateSymbolName(const char* DecoratedName, char* UnDecoratedName,
	DWORD UndecoratedLength, DWORD Flags) {
	WindowsDbgHelpEntry entry_guard;
	if (g_pfn_UnDecorateSymbolName != NULL) {
	return g_pfn_UnDecorateSymbolName(DecoratedName, UnDecoratedName, UndecoratedLength, Flags);
	}
	if (UnDecoratedName != NULL && UndecoratedLength > 0) {
	UnDecoratedName[0] = '\0';
	}
	return 0;
	}

	BOOL WindowsDbgHelp::symSetSearchPath(HANDLE hProcess, PCTSTR SearchPath) {
	WindowsDbgHelpEntry entry_guard;
	if (g_pfn_SymSetSearchPath != NULL) {
	return g_pfn_SymSetSearchPath(hProcess, SearchPath);
	}
	return FALSE;
	}

	BOOL WindowsDbgHelp::symGetSearchPath(HANDLE hProcess, PTSTR SearchPath, int SearchPathLength) {
	WindowsDbgHelpEntry entry_guard;
	if (g_pfn_SymGetSearchPath != NULL) {
	return g_pfn_SymGetSearchPath(hProcess, SearchPath, SearchPathLength);
	}
	return FALSE;
	}

	BOOL WindowsDbgHelp::stackWalk64(DWORD MachineType,
	HANDLE hProcess,
	HANDLE hThread,
	LPSTACKFRAME64 StackFrame,
	PVOID ContextRecord) {
	WindowsDbgHelpEntry entry_guard;
	if (g_pfn_StackWalk64 != NULL) {
	return g_pfn_StackWalk64(MachineType, hProcess, hThread, StackFrame,
	ContextRecord,
	NULL, // ReadMemoryRoutine
	g_pfn_SymFunctionTableAccess64, // FunctionTableAccessRoutine,
	g_pfn_SymGetModuleBase64, // GetModuleBaseRoutine
	NULL // TranslateAddressRoutine
	);
	}
	return FALSE;
	}

	PVOID WindowsDbgHelp::symFunctionTableAccess64(HANDLE hProcess, DWORD64 AddrBase) {
	WindowsDbgHelpEntry entry_guard;
	if (g_pfn_SymFunctionTableAccess64 != NULL) {
	return g_pfn_SymFunctionTableAccess64(hProcess, AddrBase);
	}
	return NULL;
	}

	DWORD64 WindowsDbgHelp::symGetModuleBase64(HANDLE hProcess, DWORD64 dwAddr) {
	WindowsDbgHelpEntry entry_guard;
	if (g_pfn_SymGetModuleBase64 != NULL) {
	return g_pfn_SymGetModuleBase64(hProcess, dwAddr);
	}
	return 0;
	}

	BOOL WindowsDbgHelp::miniDumpWriteDump(HANDLE hProcess, DWORD ProcessId, HANDLE hFile,
	MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
	PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam,
	PMINIDUMP_CALLBACK_INFORMATION CallbackParam) {
	WindowsDbgHelpEntry entry_guard;
	if (g_pfn_MiniDumpWriteDump != NULL) {
	return g_pfn_MiniDumpWriteDump(hProcess, ProcessId, hFile, DumpType,
	ExceptionParam, UserStreamParam, CallbackParam);
	}
	return FALSE;
	}

	BOOL WindowsDbgHelp::symGetLineFromAddr64(HANDLE hProcess, DWORD64 dwAddr,
	PDWORD pdwDisplacement, PIMAGEHLP_LINE64 Line) {
	WindowsDbgHelpEntry entry_guard;
	if (g_pfn_SymGetLineFromAddr64 != NULL) {
	return g_pfn_SymGetLineFromAddr64(hProcess, dwAddr, pdwDisplacement, Line);
	}
	return FALSE;
	}

	// Print one liner describing state (if library loaded, which functions are
	// missing - if any, and the dbhelp API version)
	void WindowsDbgHelp::print_state_on(outputStream* st) {
	// Note: We should not lock while printing, but this should be
	// safe to do without lock anyway.
	st->print("dbghelp: ");

	if (g_state == state_uninitialized) {
	st->print("uninitialized.");
	} else if (g_state == state_error) {
	st->print("loading error: %u", g_dll_load_error);
	} else {
	st->print("loaded successfully ");

	// We may want to print dll file name here - which may be interesting for
	// cases where more than one version exists on the system, e.g. with a
	// debugging sdk separately installed. But we get the file name in the DLL
	// section of the hs-err file too, so this may be redundant.

	// Print version.
	st->print("- version: %u.%u.%u",
	g_version.MajorVersion, g_version.MinorVersion, g_version.Revision);

	// Print any functions which failed to load.
	int num_missing = 0;
	st->print(" - missing functions: ");

	#define CHECK_AND_PRINT_IF_NULL(functionname) \
	if (g_pfn_##functionname == NULL) { \
	st->print("%s" #functionname, ((num_missing > 0) ? ", " : "")); \
	num_missing ++; \
	}

	FOR_ALL_FUNCTIONS(CHECK_AND_PRINT_IF_NULL)

	if (num_missing == 0) {
	st->print("none");
	}
	}
	st->cr();
	}