Windows (Clang9, MSVC2017) implementation

Remaining issues:
* some warinings

CMakeLists.txt

@@ -102,7 +102,7 @@ if(BACKWARD_TESTS)
 
 		add_executable(${test_name} ${src} ${ARGN} $<TARGET_OBJECTS:test_main>)
 
-		target_link_libraries(${test_name} PRIVATE Backward::Backward test_main)
+		target_link_libraries(${test_name} PRIVATE Backward::Backward)
 
 		add_test(NAME ${name} COMMAND ${test_name})
 	endmacro()

backward.hpp

@@ -31,7 +31,7 @@
 #if defined(BACKWARD_CXX11)
 #elif defined(BACKWARD_CXX98)
 #else
-#if __cplusplus >= 201103L
+#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1800)
 #define BACKWARD_CXX11
 #define BACKWARD_ATLEAST_CXX11
 #define BACKWARD_ATLEAST_CXX98
@@ -55,11 +55,14 @@
 #if defined(BACKWARD_SYSTEM_LINUX)
 #elif defined(BACKWARD_SYSTEM_DARWIN)
 #elif defined(BACKWARD_SYSTEM_UNKNOWN)
+#elif defined(BACKWARD_SYSTEM_WINDOWS)
 #else
 #if defined(__linux) || defined(__linux__)
 #define BACKWARD_SYSTEM_LINUX
 #elif defined(__APPLE__)
 #define BACKWARD_SYSTEM_DARWIN
+#elif defined(_WIN32)
+#define BACKWARD_SYSTEM_WINDOWS
 #else
 #define BACKWARD_SYSTEM_UNKNOWN
 #endif
@@ -301,6 +304,49 @@
 #endif
 #endif // defined(BACKWARD_SYSTEM_DARWIN)
 
+#if defined(BACKWARD_SYSTEM_WINDOWS)
+
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+
+#define NOMINMAX
+#include <Windows.h>
+#include <winnt.h>
+
+#include <Psapi.h>
+#include <signal.h>
+
+#ifndef __clang__
+#undef NOINLINE
+#define NOINLINE __declspec(noinline)
+#endif
+
+#pragma comment(lib, "psapi.lib")
+#pragma comment(lib, "dbghelp.lib")
+
+// Comment / packing is from stackoverflow:
+// https://stackoverflow.com/questions/6205981/windows-c-stack-trace-from-a-running-app/28276227#28276227
+// Some versions of imagehlp.dll lack the proper packing directives themselves
+// so we need to do it.
+#pragma pack(push, before_imagehlp, 8)
+#include <imagehlp.h>
+#pragma pack(pop, before_imagehlp)
+
+// TODO maybe these should be undefined somewhere else?
+#undef BACKWARD_HAS_UNWIND
+#undef BACKWARD_HAS_BACKTRACE
+#if BACKWARD_HAS_PDB_SYMBOL == 1
+#else
+#undef BACKWARD_HAS_PDB_SYMBOL
+#define BACKWARD_HAS_PDB_SYMBOL 1
+#endif
+
+#endif
+
 #if BACKWARD_HAS_UNWIND == 1
 
 #include <unwind.h>
@@ -357,12 +403,15 @@ namespace system_tag {
 struct linux_tag; // seems that I cannot call that "linux" because the name
 // is already defined... so I am adding _tag everywhere.
 struct darwin_tag;
+struct windows_tag;
 struct unknown_tag;
 
 #if defined(BACKWARD_SYSTEM_LINUX)
 typedef linux_tag current_tag;
 #elif defined(BACKWARD_SYSTEM_DARWIN)
 typedef darwin_tag current_tag;
+#elif defined(BACKWARD_SYSTEM_WINDOWS)
+typedef windows_tag current_tag;
 #elif defined(BACKWARD_SYSTEM_UNKNOWN)
 typedef unknown_tag current_tag;
 #else
@@ -396,6 +445,13 @@ typedef backtrace_symbol current;
 #else
 #error "You shall not pass, until you know what you want."
 #endif
+#elif defined(BACKWARD_SYSTEM_WINDOWS)
+struct pdb_symbol;
+#if BACKWARD_HAS_PDB_SYMBOL == 1
+typedef pdb_symbol current;
+#else
+#error "You shall not pass, until you know what you want."
+#endif
 #endif
 } // namespace trace_resolver_tag
 
@@ -747,7 +803,7 @@ private:
   };
 };
 
-#else // BACKWARD_HAS_UNWIND == 0
+#elif defined(BACKWARD_HAS_BACKTRACE)
 
 template <>
 class StackTraceImpl<system_tag::current_tag> : public StackTraceImplHolder {
@@ -781,7 +837,102 @@ public:
   }
 };
 
-#endif // BACKWARD_HAS_UNWIND
+#elif defined(BACKWARD_SYSTEM_WINDOWS)
+
+template <>
+class StackTraceImpl<system_tag::current_tag> : public StackTraceImplHolder {
+public:
+  // We have to load the machine type from the image info
+  // So we first initialize the resolver, and it tells us this info
+  void set_machine_type(DWORD machine_type) { machine_type_ = machine_type; }
+  void set_context(CONTEXT *ctx) { ctx_ = ctx; }
+  void set_thread_handle(HANDLE handle) { thd_ = handle; }
+
+  NOINLINE
+  size_t load_here(size_t depth = 32) {
+
+    CONTEXT localCtx; // used when no context is provided
+
+    if (depth == 0) {
+      return 0;
+    }
+
+    if (!ctx_) {
+      ctx_ = &localCtx;
+      RtlCaptureContext(ctx_);
+    }
+
+    if (!thd_) {
+      thd_ = GetCurrentThread();
+    }
+
+    HANDLE process = GetCurrentProcess();
+
+    STACKFRAME64 s;
+    memset(&s, 0, sizeof(STACKFRAME64));
+
+    // TODO: 32 bit context capture
+    s.AddrStack.Mode = AddrModeFlat;
+    s.AddrFrame.Mode = AddrModeFlat;
+    s.AddrPC.Mode = AddrModeFlat;
+#ifdef _M_X64
+    s.AddrPC.Offset = ctx_->Rip;
+    s.AddrStack.Offset = ctx_->Rsp;
+    s.AddrFrame.Offset = ctx_->Rbp;
+#else
+    s.AddrPC.Offset = ctx_->Eip;
+    s.AddrStack.Offset = ctx_->Esp;
+    s.AddrFrame.Offset = ctx_->Ebp;
+#endif
+
+    if (!machine_type_) {
+#ifdef _M_X64
+      machine_type_ = IMAGE_FILE_MACHINE_AMD64;
+#else
+      machine_type_ = IMAGE_FILE_MACHINE_I386;
+#endif
+    }
+
+    for (;;) {
+      // NOTE: this only works if PDBs are already loaded!
+      SetLastError(0);
+      if (!StackWalk64(machine_type_, process, thd_, &s, ctx_, NULL,
+                       SymFunctionTableAccess64, SymGetModuleBase64, NULL))
+        break;
+
+      if (s.AddrReturn.Offset == 0)
+        break;
+
+      _stacktrace.push_back(reinterpret_cast<void *>(s.AddrPC.Offset));
+
+      if (size() >= depth)
+        break;
+    }
+
+    return size();
+  }
+
+  size_t load_from(void *addr, size_t depth = 32) {
+    load_here(depth + 8);
+
+    for (size_t i = 0; i < _stacktrace.size(); ++i) {
+      if (_stacktrace[i] == addr) {
+        skip_n_firsts(i);
+        break;
+      }
+    }
+
+    _stacktrace.resize(std::min(_stacktrace.size(), skip_n_firsts() + depth));
+    return size();
+  }
+
+private:
+  DWORD machine_type_ = 0;
+  HANDLE thd_ = 0;
+  CONTEXT *ctx_ = nullptr;
+};
+
+#endif
 
 class StackTrace : public StackTraceImpl<system_tag::current_tag> {};
 
@@ -3068,6 +3219,132 @@ class TraceResolverImpl<system_tag::darwin_tag>
 
 #endif // BACKWARD_SYSTEM_DARWIN
 
+#ifdef BACKWARD_SYSTEM_WINDOWS
+
+// Load all symbol info
+// Based on:
+// https://stackoverflow.com/questions/6205981/windows-c-stack-trace-from-a-running-app/28276227#28276227
+
+struct module_data {
+  std::string image_name;
+  std::string module_name;
+  void *base_address;
+  DWORD load_size;
+};
+
+class get_mod_info {
+  HANDLE process;
+  static const int buffer_length = 4096;
+
+public:
+  get_mod_info(HANDLE h) : process(h) {}
+
+  module_data operator()(HMODULE module) {
+    module_data ret;
+    char temp[buffer_length];
+    MODULEINFO mi;
+
+    GetModuleInformation(process, module, &mi, sizeof(mi));
+    ret.base_address = mi.lpBaseOfDll;
+    ret.load_size = mi.SizeOfImage;
+
+    GetModuleFileNameEx(process, module, temp, sizeof(temp));
+    ret.image_name = temp;
+    GetModuleBaseName(process, module, temp, sizeof(temp));
+    ret.module_name = temp;
+    std::vector<char> img(ret.image_name.begin(), ret.image_name.end());
+    std::vector<char> mod(ret.module_name.begin(), ret.module_name.end());
+    SymLoadModule64(process, 0, &img[0], &mod[0], (DWORD64)ret.base_address,
+                    ret.load_size);
+    return ret;
+  }
+};
+
+template <> class TraceResolverImpl<system_tag::windows_tag> {
+public:
+  TraceResolverImpl() {
+
+    HANDLE process = GetCurrentProcess();
+
+    std::vector<module_data> modules;
+    DWORD cbNeeded;
+    std::vector<HMODULE> module_handles(1);
+    SymInitialize(process, NULL, false);
+    DWORD symOptions = SymGetOptions();
+    symOptions |= SYMOPT_LOAD_LINES | SYMOPT_UNDNAME;
+    SymSetOptions(symOptions);
+    EnumProcessModules(process, &module_handles[0],
+                       module_handles.size() * sizeof(HMODULE), &cbNeeded);
+    module_handles.resize(cbNeeded / sizeof(HMODULE));
+    EnumProcessModules(process, &module_handles[0],
+                       module_handles.size() * sizeof(HMODULE), &cbNeeded);
+    std::transform(module_handles.begin(), module_handles.end(),
+                   std::back_inserter(modules), get_mod_info(process));
+    void *base = modules[0].base_address;
+    IMAGE_NT_HEADERS *h = ImageNtHeader(base);
+    image_type = h->FileHeader.Machine;
+  }
+
+  template <class ST> void load_stacktrace(ST &) {}
+
+  static const int max_sym_len = 255;
+  struct symbol_t {
+    SYMBOL_INFO sym;
+    char buffer[max_sym_len];
+  } sym;
+
+  DWORD64 displacement;
+
+  ResolvedTrace resolve(ResolvedTrace t) {
+    HANDLE process = GetCurrentProcess();
+
+    char name[256];
+
+    memset(&sym, sizeof(sym), 0);
+    sym.sym.SizeOfStruct = sizeof(SYMBOL_INFO);
+    sym.sym.MaxNameLen = max_sym_len;
+
+    if (!SymFromAddr(process, (ULONG64)t.addr, &displacement, &sym.sym)) {
+      // TODO:  error handling everywhere
+      LPTSTR lpMsgBuf;
+      DWORD dw = GetLastError();
+
+      FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
+                        FORMAT_MESSAGE_FROM_SYSTEM |
+                        FORMAT_MESSAGE_IGNORE_INSERTS,
+                    NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                    (LPTSTR)&lpMsgBuf, 0, NULL);
+
+      printf(lpMsgBuf);
+
+      // abort();
+    }
+    UnDecorateSymbolName(sym.sym.Name, (PSTR)name, 256, UNDNAME_COMPLETE);
+
+    DWORD offset = 0;
+    IMAGEHLP_LINE line;
+    if (SymGetLineFromAddr(process, (ULONG64)t.addr, &offset, &line)) {
+      t.object_filename = line.FileName;
+      t.source.filename = line.FileName;
+      t.source.line = line.LineNumber;
+      t.source.col = offset;
+    }
+
+    t.source.function = name;
+    t.object_filename = "";
+    t.object_function = name;
+
+    return t;
+  }
+
+  DWORD machine_type() const { return image_type; }
+
+private:
+  DWORD image_type;
+};
+
+#endif
+
 class TraceResolver : public TraceResolverImpl<system_tag::current_tag> {};
 
 /*************** CODE SNIPPET ***************/
@@ -3379,6 +3656,8 @@ public:
     return os;
   }
 
+  TraceResolver const &resolver() const { return _resolver; }
+
 private:
   TraceResolver _resolver;
   SnippetFactory _snippets;
@@ -3623,6 +3902,179 @@ private:
 
 #endif // BACKWARD_SYSTEM_LINUX || BACKWARD_SYSTEM_DARWIN
 
+#ifdef BACKWARD_SYSTEM_WINDOWS
+
+class SignalHandling {
+public:
+  SignalHandling(const std::vector<int> & = std::vector<int>())
+      : reporter_thread_([]() {
+          /* We handle crashes in a utility thread:
+            backward structures and some Windows functions called here
+            need stack space, which we do not have when we encounter a
+            stack overflow.
+            To support reporting stack traces during a stack overflow,
+            we create a utility thread at startup, which waits until a
+            crash happens or the program exits normally. */
+
+          {
+            std::unique_lock<std::mutex> lk(mtx());
+            cv().wait(lk, [] { return crashed() != crash_status::running; });
+          }
+          if (crashed() == crash_status::crashed) {
+            handle_stacktrace(skip_recs());
+          }
+          {
+            std::unique_lock<std::mutex> lk(mtx());
+            crashed() = crash_status::ending;
+          }
+          cv().notify_one();
+        }) {
+    SetUnhandledExceptionFilter(crash_handler);
+
+    signal(SIGABRT, signal_handler);
+    _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
+
+    set_terminate(&terminator);
+    set_unexpected(&terminator);
+    _set_purecall_handler(&terminator);
+    _set_invalid_parameter_handler(&invalid_parameter_handler);
+  }
+  bool loaded() const { return true; }
+
+  ~SignalHandling() {
+    {
+      std::unique_lock<std::mutex> lk(mtx());
+      crashed() = crash_status::normal_exit;
+    }
+
+    cv().notify_one();
+
+    reporter_thread_.join();
+  }
+
+private:
+  static CONTEXT *ctx() {
+    static CONTEXT data;
+    return &data;
+  }
+
+  enum class crash_status { running, crashed, normal_exit, ending };
+
+  static crash_status &crashed() {
+    static crash_status data;
+    return data;
+  }
+
+  static std::mutex &mtx() {
+    static std::mutex data;
+    return data;
+  }
+
+  static std::condition_variable &cv() {
+    static std::condition_variable data;
+    return data;
+  }
+
+  static HANDLE &thread_handle() {
+    static HANDLE handle;
+    return handle;
+  }
+
+  std::thread reporter_thread_;
+
+  // TODO: how not to hardcode these?
+  static const constexpr int signal_skip_recs =
+#ifdef __clang__
+      // With clang, RtlCaptureContext also captures the stack frame of the
+      // current function Below that, there ar 3 internal Windows functions
+      4
+#else
+      // With MSVC cl, RtlCaptureContext misses the stack frame of the current
+      // function The first entries during StackWalk are the 3 internal Windows
+      // functions
+      3
+#endif
+      ;
+
+  static int &skip_recs() {
+    static int data;
+    return data;
+  }
+
+  static inline void terminator() {
+    crash_handler(signal_skip_recs);
+    abort();
+  }
+
+  static inline void signal_handler(int) {
+    crash_handler(signal_skip_recs);
+    abort();
+  }
+
+  static inline void __cdecl invalid_parameter_handler(const wchar_t *,
+                                                       const wchar_t *,
+                                                       const wchar_t *,
+                                                       unsigned int,
+                                                       uintptr_t) {
+    crash_handler(signal_skip_recs);
+    abort();
+  }
+
+  NOINLINE static LONG WINAPI crash_handler(EXCEPTION_POINTERS *info) {
+    // The exception info supplies a trace from exactly where the issue was,
+    // no need to skip records
+    crash_handler(0, info->ContextRecord);
+    return EXCEPTION_CONTINUE_SEARCH;
+  }
+
+  NOINLINE static void crash_handler(int skip, CONTEXT *ct = nullptr) {
+
+    if (ct == nullptr) {
+      RtlCaptureContext(ctx());
+    } else {
+      memcpy(ctx(), ct, sizeof(CONTEXT));
+    }
+    DuplicateHandle(GetCurrentProcess(), GetCurrentThread(),
+                    GetCurrentProcess(), &thread_handle(), 0, FALSE,
+                    DUPLICATE_SAME_ACCESS);
+
+    skip_recs() = skip;
+
+    {
+      std::unique_lock<std::mutex> lk(mtx());
+      crashed() = crash_status::crashed;
+    }
+
+    cv().notify_one();
+
+    {
+      std::unique_lock<std::mutex> lk(mtx());
+      cv().wait(lk, [] { return crashed() != crash_status::crashed; });
+    }
+  }
+
+  static void handle_stacktrace(int skip_frames = 0) {
+    // printer creates the TraceResolver, which can supply us a machine type
+    // for stack walking. Without this, StackTrace can only guess using some
+    // macros.
+    // StackTrace also requires that the PDBs are already loaded, which is done
+    // in the constructor of TraceResolver
+    Printer printer;
+
+    StackTrace st;
+    st.set_machine_type(printer.resolver().machine_type());
+    st.set_context(ctx());
+    st.set_thread_handle(thread_handle());
+    st.load_here(32 + skip_frames);
+    st.skip_n_firsts(skip_frames);
+
+    printer.address = true;
+    printer.print(st, std::cerr);
+  }
+};
+
+#endif // BACKWARD_SYSTEM_WINDOWS
+
 #ifdef BACKWARD_SYSTEM_UNKNOWN
 
 class SignalHandling {

test/_test_main.cpp

@@ -24,15 +24,26 @@
 #include "test.hpp"
 #include <cstdio>
 #include <cstdlib>
+
+#ifdef _WIN32
+#include <Windows.h>
+#define strcasecmp _stricmp
+#else
 #include <sys/wait.h>
 #include <unistd.h>
+#endif
 
 #if defined(__has_include) && __has_include(<error.h>)
 #include <error.h>
 #else
 #include <stdarg.h>
 
-#ifndef __APPLE__
+#ifdef _WIN32
+char argv0[MAX_PATH];
+inline const char *getprogname() {
+  return GetModuleFileName(NULL, argv0, sizeof(argv0)) ? argv0 : NULL;
+}
+#elif !defined(__APPLE__)
 // N.B.  getprogname() is an Apple/BSD-ism.
 // program_invocation_name is a GLIBC-ism, but it's also
 //  supported by libmusl.
@@ -59,13 +70,71 @@ void error(int status, int errnum, const char *format, ...) {
 }
 #endif
 
-test::test_registry_t test::test_registry;
 using namespace test;
 
-bool run_test(TestBase &test) {
+bool run_test(TestBase &test, bool use_child_process = true) {
+  if (!use_child_process) {
+    exit(static_cast<int>(test.run()));
+  }
+
   printf("-- running test case: %s\n", test.name);
 
   fflush(stdout);
+
+  test::TestStatus status = test::SUCCESS;
+
+#ifdef _WIN32
+  char filename[256];
+  GetModuleFileName(NULL, filename, 256); // TODO: check for error
+  std::string cmd_line = filename;
+  cmd_line += " --nofork ";
+  cmd_line += test.name;
+
+  STARTUPINFO si;
+  PROCESS_INFORMATION pi;
+  ZeroMemory(&si, sizeof(si));
+  si.cb = sizeof(si);
+  ZeroMemory(&pi, sizeof(pi));
+
+  if (!CreateProcessA(nullptr, const_cast<char *>(cmd_line.c_str()), nullptr,
+                      nullptr, FALSE, 0, nullptr, nullptr, &si, &pi)) {
+    printf("unable to create process\n");
+    exit(-1);
+  }
+
+  WaitForSingleObject(pi.hProcess, INFINITE);
+
+  DWORD exit_code;
+  GetExitCodeProcess(pi.hProcess, &exit_code);
+  switch (exit_code) {
+  case 3:
+    status = test::SIGNAL_ABORT;
+    break;
+  case 5:
+    status = test::EXCEPTION_UNCAUGHT;
+    break;
+  case EXCEPTION_ACCESS_VIOLATION:
+    status = test::SIGNAL_SEGFAULT;
+    break;
+  case EXCEPTION_STACK_OVERFLOW:
+    status = test::SIGNAL_SEGFAULT;
+    break;
+  case EXCEPTION_INT_DIVIDE_BY_ZERO:
+    status = test::SIGNAL_DIVZERO;
+    break;
+  }
+  printf("Exit code: %lu\n", exit_code);
+
+  CloseHandle(pi.hProcess);
+  CloseHandle(pi.hThread);
+
+  if (test.expected_status == test::ASSERT_FAIL) {
+    // assert calls abort on windows
+    return (status & test::SIGNAL_ABORT);
+  }
+
+#else
+
   pid_t child_pid = fork();
   if (child_pid == 0) {
     exit(static_cast<int>(test.run()));
@@ -77,8 +146,6 @@ bool run_test(TestBase &test) {
   int child_status = 0;
   waitpid(child_pid, &child_status, 0);
 
-  test::TestStatus status;
-
   if (WIFEXITED(child_status)) {
     int exit_status = WEXITSTATUS(child_status);
     if (exit_status & ~test::STATUS_MASK) {
@@ -103,10 +170,10 @@ bool run_test(TestBase &test) {
     default:
       status = test::SIGNAL_UNCAUGHT;
     }
-  } else {
-    status = test::SUCCESS;
   }
 
+#endif
+
   if (test.expected_status == test::FAILED) {
     return (status & test::FAILED);
   }
@@ -120,6 +187,25 @@ bool run_test(TestBase &test) {
 
 int main(int argc, const char *const argv[]) {
 
+#ifdef _WIN32
+  _set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
+#endif
+
+  if (argc == 3 && strcmp("--nofork", argv[1]) == 0) {
+    // Windows has no fork, so we simulate it
+    // we only execute one test, without forking
+    for (test_registry_t::iterator it = test_registry().begin();
+         it != test_registry().end(); ++it) {
+      TestBase &test = **it;
+      if (strcasecmp(argv[2], test.name) == 0) {
+        run_test(test, false);
+
+        return 0;
+      }
+    }
+    return -1;
+  }
+
   size_t success_cnt = 0;
   size_t total_cnt = 0;
   for (test_registry_t::iterator it = test_registry().begin();
@@ -145,9 +231,9 @@ int main(int argc, const char *const argv[]) {
       printf("** test case FAILED : %s\n", test.name);
     }
   }
-  printf("-- tests passing: %lu/%lu", success_cnt, total_cnt);
+  printf("-- tests passing: %zu/%zu", success_cnt, total_cnt);
   if (total_cnt) {
-    printf(" (%lu%%)\n", success_cnt * 100 / total_cnt);
+    printf(" (%zu%%)\n", success_cnt * 100 / total_cnt);
   } else {
     printf("\n");
   }

test/stacktrace.cpp

@@ -24,17 +24,19 @@
 #include "backward.hpp"
 #include "test/test.hpp"
 #include <cstdio>
+#include <iostream>
 
 using namespace backward;
 
 void collect_trace(StackTrace &st) { st.load_here(); }
 
 TEST(minitrace) {
+  Printer printer;
+
   StackTrace st;
   collect_trace(st);
 
-  Printer printer;
+  printer.print(st, std::cout);
-  printer.print(st, stdout);
 }
 
 void d(StackTrace &st) { st.load_here(); }
@@ -46,9 +48,10 @@ void b(StackTrace &st) { return c(st); }
 NOINLINE void a(StackTrace &st) { return b(st); }
 
 TEST(smalltrace) {
+  Printer printer;
+
   StackTrace st;
   a(st);
 
-  Printer printer;
+  printer.print(st, std::cout);
-  printer.print(st, stdout);
 }

test/suicide.cpp

@@ -25,7 +25,10 @@
 
 #include "test/test.hpp"
 #include <cstdio>
+
+#ifndef _WIN32
 #include <sys/resource.h>
+#endif
 
 using namespace backward;
 
@@ -75,9 +78,11 @@ TEST_DIVZERO(divide_by_zero) {
 int bye_bye_stack(int i) { return bye_bye_stack(i + 1) + bye_bye_stack(i * 2); }
 
 TEST_SEGFAULT(stackoverflow) {
+#ifndef _WIN32
   struct rlimit limit;
   limit.rlim_max = 8096;
   setrlimit(RLIMIT_STACK, &limit);
+#endif
   int r = bye_bye_stack(42);
   std::cout << "r=" << r << std::endl;
 }