Catching unhandled exceptions

Question

In Windows, I have some threads. Two of them terminate with exception (null pointer dereference, for example). I have SetUnhandledExceptionFilter(...) which starts dump generating on the first exception. On the second exception, the whole program dies. Is there any way to handle such situations? All critical errors except first shall be ignored.

pseudo code:

  void job()
  {
   ...
   RaiseException(someCode, someFlags, 0, nullptr); // or doing something wrong, like nullptr dereference
  }

  int main() {
    SetUnhandledExceptionFilter(getDump);
    std::thread t1(job), t2(job); 
    ...
  }

UPD: replace misunderstanded string *nullptr = 0xbad;

UPD2: forget about nullptr

UPD3: so far i came to this workaround

#include <stdio.h>
#include <windows.h>  // for EXCEPTION_ACCESS_VIOLATION
#include <excpt.h>

#include <mutex>


LONG __stdcall HandleException(EXCEPTION_POINTERS* exinfo)
{
    static HANDLE mutex = CreateMutex(nullptr, FALSE, __TEXT("HandleException"));
    while(WaitForSingleObject(mutex, INFINITE) != WAIT_OBJECT_0);

    HANDLE event = CreateEvent(nullptr, TRUE, FALSE, __TEXT("Doing Dump"));
    puts("Doing Dump");
    WaitForSingleObject(event, 5000); // do dump routine
    puts("Done Dump");

    return EXCEPTION_EXECUTE_HANDLER;
}

int filter(unsigned int code, struct _EXCEPTION_POINTERS *ep)
{
    puts("in filter.");
    return HandleException(ep);
}

void Job()
{
    puts("hello");
    int *p = 0x00000000;  // pointer to NULL
    *p = 13;  // causes an access violation exception;
}

void safeJob(void (*job)())
{
    __try {
         job();
    } __except (filter(GetExceptionCode(), GetExceptionInformation())) {
        exit(-1);
    }
}
int main()
{

    SetUnhandledExceptionFilter(HandleException);
    std::thread t1(std::bind(safeJob, Job));
    std::thread t2(std::bind(safeJob, Job));
    t1.join();
    t2.join();
    return 0;
}

Answer 1

Per Remy's comment, an access violation is a Windows "Structured Exception," not a C++ exception, and it can be handled with Microsoft-specific extensions such as a try-except statement.

https://msdn.microsoft.com/en-us/library/s58ftw19.aspx

Example:

__try
{
 // doing something wrong
 *nullptr = 0xbad;
}
__except(EXCEPTION_EXECUTE_HANDLER)
{
  // exception quashed!
}

Answer 2

There is a misconception that "doing something bad" will throw exceptions. That is not correct. If you are doing things that are causes for undefined behavior, you should not expect any predictable behavior. If your platform throws an exception, that's great but realize that you can't count on it.

Your best bet is to avoid writing such code.

More on undefined behavior can be found at Undefined, unspecified and implementation-defined behavior.

Answer 3

*nullptr = 0xbad;

You've caused undefined behavior. You can't even expect that code before this has run correctly. Undefined behavior can have effects in time before it's hit due to compiler optimizations and the rights it has to assume UB won't happen.

There is zero way to protect yourself from UB. You have to implement code standards that discourage or eliminate the possibility for the kinds of errors that cause it. That is the only thing you can do to protect yourself from UB--don't create it.

This is why every team should have a language lawyer who can tell what's UB. The effects of UB can be very off the wall and happen clear across the program at some later or previous date. This person should be familiar with modern, idiomatic C++ and in charge of creating, or at least playing a huge advisory roll, to the teams creation of coding standards.

Second requirement should be implementation lawyer. Someone who can tell you what to expect from UB. This is a much more advanced...more wizardry than science kind of thing. What they know doesn't always work that way and the domain of UB activity is HUGE! These guys don't grow on trees--I don't qualify except at a very minimalistic level.