seh.h

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <cstdint>
#include <exception>
 
#include <rex/platform.h>
#include <rex/platform/thread.h>
#include <rex/types.h>
#include <rex/utility.h>
 
#if !REX_PLATFORM_WIN32
#include <setjmp.h>
#endif
 
namespace rex::platform {
 
#if !REX_PLATFORM_WIN32
struct SEHScope {
  sigjmp_buf env;            
  SEHScope* outer = nullptr; 
  u32 host_depth = 0;        
};
#endif
 
struct SEHThreadState {
  u32 code = 0;               
  uintptr_t info[2] = {0, 0}; 
#if !REX_PLATFORM_WIN32
  SEHScope* top = nullptr;
  u32 host_depth = 0; 
#endif
};

REX_PPC_API SEHThreadState& GetSEHThreadState();

REX_PPC_API int SEHFilter(u32 code, void* exception_pointers);

[[noreturn]] REX_PPC_API void SEHRethrow();

REX_PPC_API void SEHInitialize();
 
#if !REX_PLATFORM_WIN32
inline void SEHEnter(SEHScope& scope) {
  SEHThreadState& state = GetSEHThreadState();
  scope.outer = state.top;
  scope.host_depth = state.host_depth;
  state.top = &scope;
}

inline void SEHLeave(SEHScope& scope) {
  SEHThreadState& state = GetSEHThreadState();
  if (state.top == &scope) {
    state.top = scope.outer;
  }
}

class HostCallDepth : public NonCopyable {
 public:
  HostCallDepth() { ++GetSEHThreadState().host_depth; }
  ~HostCallDepth() { --GetSEHThreadState().host_depth; }
};
#endif
 
}  // namespace rex::platform
 
namespace rex {

class SEHException : public std::exception {
 public:
  enum Code : u32 {
    kAccessViolation = 0xC0000005,
    kInPageError = 0xC0000006, 
    kIllegalInstruction = 0xC000001D,
    kStackOverflow = 0xC00000FD,
    kFloatDivideByZero = 0xC000008E, 
    kIntegerDivideByZero = 0xC0000094,
    kUnknown = 0xFFFFFFFF
  };
 
  explicit SEHException(Code code, uintptr_t address = 0) : code_(code), address_(address) {}

  const char* what() const noexcept override {
    switch (code_) {
      case kAccessViolation:
        return "SEH: Access Violation";
      case kInPageError:
        return "SEH: In-Page Error";
      case kIllegalInstruction:
        return "SEH: Illegal Instruction";
      case kStackOverflow:
        return "SEH: Stack Overflow";
      case kFloatDivideByZero:
        return "SEH: Float Divide by Zero";
      case kIntegerDivideByZero:
        return "SEH: Integer Divide by Zero";
      default:
        return "SEH: Unknown Exception";
    }
  }
 
  Code GetCode() const noexcept { return code_; }

  uintptr_t GetAddress() const noexcept { return address_; }
 
 private:
  Code code_;
  uintptr_t address_;
};
 
inline void InitializeSEHThread() {
  platform::GetSEHThreadState() = {};
}
 
inline void InitializeSEH() {
  platform::SEHInitialize();
}
 
#if REX_PLATFORM_WIN32

#define REX_SEH_TRY __try {
#define REX_SEH_CATCH \
  }                   \
  __except (::rex::platform::SEHFilter(GetExceptionCode(), GetExceptionInformation())) {
#define REX_SEH_CATCH_ALL \
  }                       \
  __except (::rex::platform::SEHFilter(GetExceptionCode(), GetExceptionInformation())) {
#define REX_SEH_RETHROW ::rex::platform::SEHRethrow()
 
#define REX_SEH_END }

#define REX_SEH_RETURN return
 
#else

#define REX_SEH_TRY                           \
  {                                           \
    ::rex::platform::SEHScope rex_seh_scope;  \
    ::rex::platform::SEHEnter(rex_seh_scope); \
    if (sigsetjmp(rex_seh_scope.env, 0) == 0)

#define REX_SEH_CATCH else

#define REX_SEH_CATCH_ALL else

#define REX_SEH_RETHROW ::rex::platform::SEHRethrow()
 
#define REX_SEH_END                         \
  ::rex::platform::SEHLeave(rex_seh_scope); \
  }

#define REX_SEH_RETURN                        \
  do {                                        \
    ::rex::platform::SEHLeave(rex_seh_scope); \
    return;                                   \
  } while (0)
 
#endif  // REX_PLATFORM_WIN32
 
}  // namespace rex