StackWalker added for windows. TODO: Add License Block

git-svn-id: http://www.openflipper.org/svnrepo/OpenFlipper/branches/Free@17427 383ad7c9-94d9-4d36-a494-682f7c89f535

CoreApp/CMakeLists.txt

@@ -38,6 +38,12 @@ else (APPLE)
    )
 endif(APPLE)
 
+if (WIN32)
+	SET(WIN_EXTRA_DIRS "../StackWalker" )
+else(WIN32)
+	SET(WIN_EXTRA_DIRS "")
+endif(WIN32)
+
 # source code directories
 set (directories 
   .. 
@@ -62,6 +68,7 @@ set (directories
   ../widgets/stereoSettingsWidget
   ../widgets/postProcessorWidget
   ../widgets/rendererWidget
+  ${WIN_EXTRA_DIRS}
 )
 
 # collect all header,source and ui files

OpenFlipper.cc

@@ -68,64 +68,36 @@
 #include <execinfo.h>
 #endif
 
+#ifdef WIN32
+#ifndef NDEBUG
+#define WIN_GET_DEBUG_CONSOLE
+#endif
+#endif
+
 #ifdef USE_OPENMP
 #include <omp.h>
 #endif
 
+#ifdef WIN32
+  #include "StackWalker/StackWalker.hh"
+
+  class StackWalkerToConsole : public StackWalker
+  {
+  protected:
+	  virtual void OnOutput(LPCSTR szText)
+    	{
+	  	  printf("%s",szText);
+	  }
+  };
+#endif
+
 // Includes for windows debugging console
 #ifdef WIN32
+#ifdef WIN_GET_DEBUG_CONSOLE
   #include <fcntl.h>
   #include <io.h>
 #endif
-
-// #ifndef WIN32
-//
-// #include <sys/resource.h>
-//
-// void getSystemInfo() {
-//
-//   struct rusage resource_usage;
-//   if (getrusage(RUSAGE_SELF, &resource_usage))
-//   {
-//     //error - call to getrusage failed - handle itf
-//     std::cerr << "Unable to get process information" << std::endl;
-//   }
-//   else
-//   {
-//     std::cerr << "Got process information" << std::endl;
-//     std::cerr << "Maximum resident size   : " << resource_usage.ru_maxrss << std::endl;
-//     std::cerr << "Shared Memory size      : " << resource_usage.ru_ixrss << std::endl;
-//     std::cerr << "Unshared Data size      : " << resource_usage.ru_idrss << std::endl;
-//     std::cerr << "Unshared Stack size     : " << resource_usage.ru_isrss << std::endl;
-//     std::cerr << "Page faults             : " << resource_usage.ru_majflt << std::endl;
-//     std::cerr << "Block input operations  : " << resource_usage.ru_inblock << std::endl;
-//     std::cerr << "Block output operations : " << resource_usage.ru_oublock << std::endl;
-//
-//
-//     //call successful
-//     //get values for resident set size (ru_idrss)
-//     //swap space is probably not accounted for but thats all what this
-//     //call gives you...
-
-//     struct rusage {
-//         struct timeval ru_utime; /* user time used */
-//         struct timeval ru_stime; /* system time used */
-//         long   ru_minflt;        /* page reclaims */
-//         long   ru_nswap;         /* swaps */
-//         long   ru_msgsnd;        /* messages sent */
-//         long   ru_msgrcv;        /* messages received */
-//         long   ru_nsignals;      /* signals received */
-//         long   ru_nvcsw;         /* voluntary context switches */
-//         long   ru_nivcsw;        /* involuntary context switches */
-//     };
-
-
-//   }
-
-// }
-
-// #endif
-
+#endif
 
 
 enum {OPT_HELP , OPT_STEREO, OPT_BATCH ,OPT_CONSOLE_LOG , OPT_DEBUGGING, OPT_FULLSCREEN,
@@ -199,6 +171,8 @@ void backtrace()
 }
 #endif
 
+
+
 void segfaultHandling (int) {
 
   // prevent infinite recursion if segfaultHandling() causes another segfault
@@ -221,10 +195,18 @@ void segfaultHandling (int) {
 
 #endif
 
+#ifdef WIN32
+  StackWalkerToConsole sw;
+  sw.ShowCallstack();
+
+#endif
+
+
   std::abort();
 }
 
 #ifdef WIN32
+#ifdef WIN_GET_DEBUG_CONSOLE
     void getConsole() {
       //Create a console for this application
       AllocConsole();
@@ -248,6 +230,7 @@ void segfaultHandling (int) {
       setvbuf(stdin, NULL, _IONBF, 0);
     }
 #endif
+#endif
 
 bool openPolyMeshes = false;
 bool remoteControl  = false;
@@ -350,7 +333,7 @@ int main(int argc, char **argv)
   OpenFlipper::Options::windowTitle(TOSTRING(PRODUCT_STRING)" v" + OpenFlipper::Options::coreVersion());
 
 #ifdef WIN32
-    #ifndef NDEBUG
+#ifdef WIN_GET_DEBUG_CONSOLE
   getConsole();
 #endif
 #endif

StackWalker/StackWalker.hh

+/**********************************************************************
+ * 
+ * StackWalker.h
+ *
+ *
+ *
+ * LICENSE (http://www.opensource.org/licenses/bsd-license.php)
+ *
+ *   Copyright (c) 2005-2009, Jochen Kalmbach
+ *   All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without modification, 
+ *   are permitted provided that the following conditions are met:
+ *
+ *   Redistributions of source code must retain the above copyright notice, 
+ *   this list of conditions and the following disclaimer. 
+ *   Redistributions in binary form must reproduce the above copyright notice, 
+ *   this list of conditions and the following disclaimer in the documentation 
+ *   and/or other materials provided with the distribution. 
+ *   Neither the name of Jochen Kalmbach nor the names of its contributors may be 
+ *   used to endorse or promote products derived from this software without 
+ *   specific prior written permission. 
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
+ *   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+ *   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
+ *   ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 
+ *   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
+ *   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+ *   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 
+ *   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
+ *   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * **********************************************************************/
+// #pragma once is supported starting with _MCS_VER 1000, 
+// so we need not to check the version (because we only support _MSC_VER >= 1100)!
+#pragma once
+
+#include <windows.h>
+
+// special defines for VC5/6 (if no actual PSDK is installed):
+#if _MSC_VER < 1300
+typedef unsigned __int64 DWORD64, *PDWORD64;
+#if defined(_WIN64)
+typedef unsigned __int64 SIZE_T, *PSIZE_T;
+#else
+typedef unsigned long SIZE_T, *PSIZE_T;
+#endif
+#endif  // _MSC_VER < 1300
+
+class StackWalkerInternal;  // forward
+class StackWalker
+{
+public:
+  typedef enum StackWalkOptions
+  {
+    // No addition info will be retrived 
+    // (only the address is available)
+    RetrieveNone = 0,
+    
+    // Try to get the symbol-name
+    RetrieveSymbol = 1,
+    
+    // Try to get the line for this symbol
+    RetrieveLine = 2,
+    
+    // Try to retrieve the module-infos
+    RetrieveModuleInfo = 4,
+    
+    // Also retrieve the version for the DLL/EXE
+    RetrieveFileVersion = 8,
+    
+    // Contains all the abouve
+    RetrieveVerbose = 0xF,
+    
+    // Generate a "good" symbol-search-path
+    SymBuildPath = 0x10,
+    
+    // Also use the public Microsoft-Symbol-Server
+    SymUseSymSrv = 0x20,
+    
+    // Contains all the abouve "Sym"-options
+    SymAll = 0x30,
+    
+    // Contains all options (default)
+    OptionsAll = 0x3F
+  } StackWalkOptions;
+
+  StackWalker(
+    int options = OptionsAll, // 'int' is by design, to combine the enum-flags
+    LPCSTR szSymPath = NULL, 
+    DWORD dwProcessId = GetCurrentProcessId(), 
+    HANDLE hProcess = GetCurrentProcess()
+    );
+  StackWalker(DWORD dwProcessId, HANDLE hProcess);
+  virtual ~StackWalker();
+
+  typedef BOOL (__stdcall *PReadProcessMemoryRoutine)(
+    HANDLE      hProcess,
+    DWORD64     qwBaseAddress,
+    PVOID       lpBuffer,
+    DWORD       nSize,
+    LPDWORD     lpNumberOfBytesRead,
+    LPVOID      pUserData  // optional data, which was passed in "ShowCallstack"
+    );
+
+  BOOL LoadModules();
+
+  BOOL ShowCallstack(
+    HANDLE hThread = GetCurrentThread(), 
+    const CONTEXT *context = NULL, 
+    PReadProcessMemoryRoutine readMemoryFunction = NULL,
+    LPVOID pUserData = NULL  // optional to identify some data in the 'readMemoryFunction'-callback
+    );
+
+#if _MSC_VER >= 1300
+// due to some reasons, the "STACKWALK_MAX_NAMELEN" must be declared as "public" 
+// in older compilers in order to use it... starting with VC7 we can declare it as "protected"
+protected:
+#endif
+	enum { STACKWALK_MAX_NAMELEN = 1024 }; // max name length for found symbols
+
+protected:
+  // Entry for each Callstack-Entry
+  typedef struct CallstackEntry
+  {
+    DWORD64 offset;  // if 0, we have no valid entry
+    CHAR name[STACKWALK_MAX_NAMELEN];
+    CHAR undName[STACKWALK_MAX_NAMELEN];
+    CHAR undFullName[STACKWALK_MAX_NAMELEN];
+    DWORD64 offsetFromSmybol;
+    DWORD offsetFromLine;
+    DWORD lineNumber;
+    CHAR lineFileName[STACKWALK_MAX_NAMELEN];
+    DWORD symType;
+    LPCSTR symTypeString;
+    CHAR moduleName[STACKWALK_MAX_NAMELEN];
+    DWORD64 baseOfImage;
+    CHAR loadedImageName[STACKWALK_MAX_NAMELEN];
+  } CallstackEntry;
+
+  typedef enum CallstackEntryType {firstEntry, nextEntry, lastEntry};
+
+  virtual void OnSymInit(LPCSTR szSearchPath, DWORD symOptions, LPCSTR szUserName);
+  virtual void OnLoadModule(LPCSTR img, LPCSTR mod, DWORD64 baseAddr, DWORD size, DWORD result, LPCSTR symType, LPCSTR pdbName, ULONGLONG fileVersion);
+  virtual void OnCallstackEntry(CallstackEntryType eType, CallstackEntry &entry);
+  virtual void OnDbgHelpErr(LPCSTR szFuncName, DWORD gle, DWORD64 addr);
+  virtual void OnOutput(LPCSTR szText);
+
+  StackWalkerInternal *m_sw;
+  HANDLE m_hProcess;
+  DWORD m_dwProcessId;
+  BOOL m_modulesLoaded;
+  LPSTR m_szSymPath;
+
+  int m_options;
+  int m_MaxRecursionCount;
+
+  static BOOL __stdcall myReadProcMem(HANDLE hProcess, DWORD64 qwBaseAddress, PVOID lpBuffer, DWORD nSize, LPDWORD lpNumberOfBytesRead);
+
+  friend StackWalkerInternal;
+};  // class StackWalker
+
+
+// The "ugly" assembler-implementation is needed for systems before XP
+// If you have a new PSDK and you only compile for XP and later, then you can use 
+// the "RtlCaptureContext"
+// Currently there is no define which determines the PSDK-Version... 
+// So we just use the compiler-version (and assumes that the PSDK is 
+// the one which was installed by the VS-IDE)
+
+// INFO: If you want, you can use the RtlCaptureContext if you only target XP and later...
+//       But I currently use it in x64/IA64 environments...
+//#if defined(_M_IX86) && (_WIN32_WINNT <= 0x0500) && (_MSC_VER < 1400)
+
+#if defined(_M_IX86)
+#ifdef CURRENT_THREAD_VIA_EXCEPTION
+// TODO: The following is not a "good" implementation, 
+// because the callstack is only valid in the "__except" block...
+#define GET_CURRENT_CONTEXT(c, contextFlags) \
+  do { \
+    memset(&c, 0, sizeof(CONTEXT)); \
+    EXCEPTION_POINTERS *pExp = NULL; \
+    __try { \
+      throw 0; \
+    } __except( ( (pExp = GetExceptionInformation()) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_EXECUTE_HANDLER)) {} \
+    if (pExp != NULL) \
+      memcpy(&c, pExp->ContextRecord, sizeof(CONTEXT)); \
+      c.ContextFlags = contextFlags; \
+  } while(0);
+#else
+// The following should be enough for walking the callstack...
+#define GET_CURRENT_CONTEXT(c, contextFlags) \
+  do { \
+    memset(&c, 0, sizeof(CONTEXT)); \
+    c.ContextFlags = contextFlags; \
+    __asm    call x \
+    __asm x: pop eax \
+    __asm    mov c.Eip, eax \
+    __asm    mov c.Ebp, ebp \
+    __asm    mov c.Esp, esp \
+  } while(0);
+#endif
+
+#else
+
+// The following is defined for x86 (XP and higher), x64 and IA64:
+#define GET_CURRENT_CONTEXT(c, contextFlags) \
+  do { \
+    memset(&c, 0, sizeof(CONTEXT)); \
+    c.ContextFlags = contextFlags; \
+    RtlCaptureContext(&c); \
+} while(0);
+#endif