1 files changed, 273 insertions, 126 deletions

diff --git a/src/lj_err.c b/src/lj_err.c
index ebc9ad12..b2e7f5f8 100644
--- a/src/lj_err.c
+++ b/src/lj_err.c
@@ -20,6 +20,63 @@
 #include "lj_trace.h"
 #include "lj_vm.h"
 
+/*
+** LuaJIT can either use internal or external frame unwinding:
+**
+** - Internal frame unwinding (INT) is free-standing and doesn't require
+**   any OS or library support.
+**
+** - External frame unwinding (EXT) uses the system-provided unwind handler.
+**
+** Pros and Cons:
+**
+** - EXT requires unwind tables for *all* functions on the C stack between
+**   the pcall/catch and the error/throw. This is the default on x64,
+**   but needs to be manually enabled on x86 for non-C++ code.
+**
+** - INT is faster when actually throwing errors (but this happens rarely).
+**   Setting up error handlers is zero-cost in any case.
+**
+** - EXT provides full interoperability with C++ exceptions. You can throw
+**   Lua errors or C++ exceptions through a mix of Lua frames and C++ frames.
+**   C++ destructors are called as needed. C++ exceptions caught by pcall
+**   are converted to the string "C++ exception". Lua errors can be caught
+**   with catch (...) in C++.
+**
+** - INT has only limited support for automatically catching C++ exceptions
+**   on POSIX systems using DWARF2 stack unwinding. Other systems may use
+**   the wrapper function feature. Lua errors thrown through C++ frames
+**   cannot be caught by C++ code and C++ destructors are not run.
+**
+** INT is the default on x86 systems, EXT is the default on x64 systems.
+**
+** EXT can only be manually enabled on POSIX/x86 systems using DWARF2 stack
+** unwinding with -DLUAJIT_UNWIND_EXTERNAL. *All* C code must be compiled
+** with -funwind-tables (or -fexceptions). This includes LuaJIT itself (set
+** TARGET_CFLAGS), all of your C/Lua binding code, all loadable C modules
+** and all C libraries that have callbacks which may be used to call back
+** into Lua. C++ code must *not* be compiled with -fno-exceptions.
+**
+** EXT cannot be enabled on WIN32 since system exceptions use code-driven SEH.
+** EXT is mandatory on WIN64 since the calling convention has an abundance
+** of callee-saved registers (rbx, rbp, rsi, rdi, r12-r15, xmm6-xmm15).
+** EXT is mandatory on POSIX/x64 since the interpreter doesn't save r12/r13.
+*/
+
+#if defined(__ELF__) || defined(__MACH__)
+#if LJ_TARGET_X86
+#ifdef LUAJIT_UNWIND_EXTERNAL
+#define LJ_UNWIND_EXT   1
+#endif
+#elif LJ_TARGET_X64
+#define LJ_UNWIND_EXT   1
+#endif
+#elif defined(LUA_USE_WIN)
+#if LJ_TARGET_X64
+#define LJ_UNWIND_EXT   1
+#endif
+#endif
+
 /* -- Error messages ------------------------------------------------------ */
 
 /* Error message strings. */
@@ -374,117 +431,249 @@ LUA_API int lua_getstack(lua_State *L, int level, lua_Debug *ar)
   }
 }
 
-/* -- Error handling ------------------------------------------------------ */
-
-/* Return string object for error message. */
-LJ_NOINLINE GCstr *lj_err_str(lua_State *L, ErrMsg em)
-{
-  return lj_str_newz(L, err2msg(em));
-}
+/* -- Internal frame unwinding -------------------------------------------- */
 
-/* Unwind Lua stack and add error message on top. */
-LJ_NOINLINE static void unwindstack(lua_State *L, TValue *top, int errcode)
+/* Unwind Lua stack and move error message to new top. */
+LJ_NOINLINE static void unwindstack(lua_State *L, TValue *top)
 {
   lj_func_closeuv(L, top);
-  switch (errcode) {
-  case LUA_ERRMEM:
-    setstrV(L, top, lj_err_str(L, LJ_ERR_ERRMEM));
-    break;
-  case LUA_ERRERR:
-    setstrV(L, top, lj_err_str(L, LJ_ERR_ERRERR));
-    break;
-  case LUA_ERRSYNTAX:
-  case LUA_ERRRUN:
-    copyTV(L, top, L->top - 1);
-    break;
-  default:
-    lua_assert(0);
-    break;
+  if (top < L->top-1) {
+    copyTV(L, top, L->top-1);
+    L->top = top+1;
   }
-  L->top = top+1;
   lj_state_relimitstack(L);
 }
 
-/* Throw error. Find catch frame, unwind stack and continue. */
-LJ_NOINLINE void lj_err_throw(lua_State *L, int errcode)
+/* Unwind until stop frame. Optionally cleanup frames. */
+static void *err_unwind(lua_State *L, void *stopcf, int errcode)
 {
   TValue *frame = L->base-1;
   void *cf = L->cframe;
-  global_State *g = G(L);
-  if (L->status == LUA_ERRERR+1) {  /* Don't touch the stack during lua_open. */
-    lj_vm_unwind_c(cf, errcode);
-    goto uncaught;  /* unreachable */
-  }
-  lj_trace_abort(g);
-  setgcrefnull(g->jit_L);
-  L->status = 0;
   while (cf) {
-    if (cframe_nres(cframe_raw(cf)) < 0) {  /* cframe without frame? */
-      TValue *top = restorestack(L, -cframe_nres(cf));
-      if (frame < top) {
-        L->cframe = cframe_prev(cf);
-        L->base = frame+1;
-        unwindstack(L, top, errcode);
-        lj_vm_unwind_c(cf, errcode);
-        goto uncaught;  /* unreachable */
+    int32_t nres = cframe_nres(cframe_raw(cf));
+    if (nres < 0) {  /* C frame without Lua frame? */
+      TValue *top = restorestack(L, -nres);
+      if (frame < top) {  /* Frame reached? */
+        if (errcode) {
+          L->cframe = cframe_prev(cf);
+          L->base = frame+1;
+          unwindstack(L, top);
+        }
+        return cf;
       }
     }
     if (frame <= L->stack)
       break;
     switch (frame_typep(frame)) {
-    case FRAME_LUA:
+    case FRAME_LUA:  /* Lua frame. */
     case FRAME_LUAP:
       frame = frame_prevl(frame);
       break;
-    case FRAME_C:
-      if (cframe_canyield(cf)) goto uncaught;
+    case FRAME_C:  /* C frame. */
+#if LJ_UNWIND_EXT
+      if (errcode) {
+        L->cframe = cframe_prev(cf);
+        L->base = frame_prevd(frame) + 1;
+        unwindstack(L, frame);
+      } else if (cf != stopcf) {
+        cf = cframe_prev(cf);
+        frame = frame_prevd(frame);
+        break;
+      }
+      return NULL;  /* Continue unwinding. */
+#else
+      UNUSED(stopcf);
       cf = cframe_prev(cf);
-      /* fallthrough */
-    case FRAME_CONT:
-    case FRAME_VARG:
       frame = frame_prevd(frame);
       break;
-    case FRAME_CP:
-      L->cframe = cframe_prev(cf);
-      L->base = frame_prevd(frame) + 1;
-      unwindstack(L, frame, errcode);
-      lj_vm_unwind_c(cf, errcode);
-      goto uncaught;  /* unreachable */
-    case FRAME_PCALL:
-      hook_leave(g);
+#endif
+    case FRAME_CP:  /* Protected C frame. */
+      if (cframe_canyield(cf)) {  /* Resume? */
+        if (errcode) {
+          L->cframe = NULL;
+          L->status = cast_byte(errcode);
+        }
+        return cframe_raw(cf);
+      }
+      if (errcode) {
+        L->cframe = cframe_prev(cf);
+        L->base = frame_prevd(frame) + 1;
+        unwindstack(L, frame);
+      }
+      return cf;
+    case FRAME_CONT:  /* Continuation frame. */
+    case FRAME_VARG:  /* Vararg frame. */
+      frame = frame_prevd(frame);
+      break;
+    case FRAME_PCALL:  /* FF pcall() frame. */
+      if (errcode)
+        hook_leave(G(L));
       /* fallthrough */
-    case FRAME_PCALLH:
-      L->cframe = cf;
-      L->base = frame_prevd(frame) + 1;
-      unwindstack(L, L->base, errcode);
-      lj_vm_unwind_ff(cf);
-      goto uncaught;  /* unreachable */
-    default:
-      lua_assert(0);
-      goto uncaught;
+    case FRAME_PCALLH:  /* FF pcall() frame inside hook. */
+      if (errcode) {
+        L->cframe = cf;
+        L->base = frame_prevd(frame) + 1;
+        unwindstack(L, L->base);
+        return NULL;  /* Call special handler. */
+      }
+      return cf;
     }
   }
-  /* No catch frame found. Must be a resume or an unprotected error. */
-uncaught:
-  L->status = cast_byte(errcode);
-  L->cframe = NULL;
-  if (cframe_canyield(cf)) {  /* Resume? */
-    unwindstack(L, L->top, errcode);
-    lj_vm_unwind_c(cframe_raw(cf), errcode);
+  /* No C frame. */
+  if (errcode) {
+    L->cframe = NULL;
+    L->base = L->stack+1;
+    unwindstack(L, L->base);
+    if (G(L)->panic)
+      G(L)->panic(L);
+    exit(EXIT_FAILURE);
   }
-  /* Better rethrow on main thread than panic. */
-  {
-    if (L != mainthread(g))
-      lj_err_throw(mainthread(g), errcode);
-    if (g->panic) {
-      L->base = L->stack+1;
-      unwindstack(L, L->base, errcode);
-      g->panic(L);
+  return L;  /* Anything not-NULL will do. */
+}
+
+/* -- External frame unwinding -------------------------------------------- */
+
+#if defined(__ELF__) || defined(__MACH__)
+
+#include <unwind.h>
+
+#define LJ_UEXCLASS             0x4c55414a49543200ULL   /* LUAJIT2\0 */
+#define LJ_UEXCLASS_MAKE(c)     (LJ_UEXCLASS | (_Unwind_Exception_Class)(c))
+#define LJ_UEXCLASS_CHECK(cl)   (((cl) ^ LJ_UEXCLASS) <= 0xff)
+#define LJ_UEXCLASS_ERRCODE(cl) (cast_int((cl) & 0xff))
+
+/* DWARF2 personality handler referenced from interpreter .eh_frame. */
+LJ_FUNCA int lj_err_unwind_dwarf(int version, _Unwind_Action actions,
+  _Unwind_Exception_Class uexclass, struct _Unwind_Exception *uex,
+  struct _Unwind_Context *ctx)
+{
+  void *cf;
+  lua_State *L;
+  if (version != 1)
+    return _URC_FATAL_PHASE1_ERROR;
+  UNUSED(uexclass);
+  cf = (void *)_Unwind_GetCFA(ctx);
+  L = cframe_L(cf);
+  if ((actions & _UA_SEARCH_PHASE)) {
+#if LJ_UNWIND_EXT
+    if (err_unwind(L, cf, 0) == NULL)
+      return _URC_CONTINUE_UNWIND;
+#endif
+    if (!LJ_UEXCLASS_CHECK(uexclass)) {
+      setstrV(L, L->top++, lj_err_str(L, LJ_ERR_ERRCPP));
+    }
+    return _URC_HANDLER_FOUND;
+  }
+  if ((actions & _UA_CLEANUP_PHASE)) {
+    int errcode;
+    if (LJ_UEXCLASS_CHECK(uexclass)) {
+      errcode = LJ_UEXCLASS_ERRCODE(uexclass);
+    } else {
+      if ((actions & _UA_HANDLER_FRAME))
+        _Unwind_DeleteException(uex);
+      errcode = LUA_ERRRUN;
+    }
+#if LJ_UNWIND_EXT
+    if (err_unwind(L, cf, errcode)) {
+      _Unwind_SetGR(ctx, 0, errcode);
+      _Unwind_SetIP(ctx, (_Unwind_Ptr)lj_vm_unwind_c_eh);
+      return _URC_INSTALL_CONTEXT;
+    } else if ((actions & _UA_HANDLER_FRAME)) {
+      _Unwind_SetIP(ctx, (_Unwind_Ptr)lj_vm_unwind_ff_eh);
+      return _URC_INSTALL_CONTEXT;
     }
+#else
+    /* This is not the proper way to escape from the unwinder. We get away
+    ** with it on x86 because the interpreter restores all callee-saved regs.
+    */
+    lj_err_throw(L, errcode);
+#endif
+  }
+  return _URC_CONTINUE_UNWIND;
+}
+
+#if LJ_UNWIND_EXT
+/* NYI: this is not thread-safe. */
+static struct _Unwind_Exception static_uex;
+
+/* Raise DWARF2 exception. */
+static void err_raise_ext(int errcode)
+{
+  static_uex.exception_class = LJ_UEXCLASS_MAKE(errcode);
+  static_uex.exception_cleanup = NULL;
+  _Unwind_RaiseException(&static_uex);
+}
+#endif
+
+#elif defined(_WIN64)
+
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#define LJ_EXCODE               ((DWORD)0x024c4a00)
+#define LJ_EXCODE_MAKE(c)       (LJ_EXCODE | (DWORD)(c))
+#define LJ_EXCODE_CHECK(cl)     (((cl) ^ LJ_EXCODE) <= 0xff)
+#define LJ_EXCODE_ERRCODE(cl)   (cast_int((cl) & 0xff))
+
+/* NYI: Win64 exception handler for interpreter frame. */
+
+/* Raise Windows exception. */
+static void err_raise_ext(int errcode)
+{
+  RaiseException(LJ_EXCODE_MAKE(errcode), 0, 0, NULL);
+}
+
+#endif
+
+/* -- Error handling ------------------------------------------------------ */
+
+/* Throw error. Find catch frame, unwind stack and continue. */
+LJ_NOINLINE void lj_err_throw(lua_State *L, int errcode)
+{
+  global_State *g = G(L);
+  lj_trace_abort(g);
+  setgcrefnull(g->jit_L);
+  L->status = 0;
+#if LJ_UNWIND_EXT
+  err_raise_ext(errcode);
+  /*
+  ** A return from this function signals a corrupt C stack that cannot be
+  ** unwound. We have no choice but to call the panic function and exit.
+  **
+  ** Usually this is caused by a C function without unwind information.
+  ** This should never happen on x64, but may happen on x86 if you've
+  ** manually enabled LUAJIT_UNWIND_EXTERNAL and forgot to recompile *every*
+  ** non-C++ file with -funwind-tables.
+  */
+  if (G(L)->panic)
+    G(L)->panic(L);
+#else
+  {
+    void *cf = err_unwind(L, NULL, errcode);
+    if (cf)
+      lj_vm_unwind_c(cf, errcode);
+    else
+      lj_vm_unwind_ff(cframe_raw(L->cframe));
   }
+#endif
   exit(EXIT_FAILURE);
 }
 
+/* Return string object for error message. */
+LJ_NOINLINE GCstr *lj_err_str(lua_State *L, ErrMsg em)
+{
+  return lj_str_newz(L, err2msg(em));
+}
+
+/* Out-of-memory error. */
+LJ_NOINLINE void lj_err_mem(lua_State *L)
+{
+  if (L->status == LUA_ERRERR+1)  /* Don't touch the stack during lua_open. */
+    lj_vm_unwind_c(L->cframe, LUA_ERRMEM);
+  setstrV(L, L->top++, lj_err_str(L, LJ_ERR_ERRMEM));
+  lj_err_throw(L, LUA_ERRMEM);
+}
+
 /* Find error function for runtime errors. Requires an extra stack traversal. */
 static ptrdiff_t finderrfunc(lua_State *L)
 {
@@ -507,7 +696,6 @@ static ptrdiff_t finderrfunc(lua_State *L)
       frame = frame_prevl(frame);
       break;
     case FRAME_C:
-      if (cframe_canyield(cf)) return 0;
       cf = cframe_prev(cf);
       /* fallthrough */
     case FRAME_CONT:
@@ -515,6 +703,7 @@ static ptrdiff_t finderrfunc(lua_State *L)
       frame = frame_prevd(frame);
       break;
     case FRAME_CP:
+      if (cframe_canyield(cf)) return 0;
       if (cframe_errfunc(cf) >= 0)
         return cframe_errfunc(cf);
       frame = frame_prevd(frame);
@@ -540,8 +729,10 @@ LJ_NOINLINE void lj_err_run(lua_State *L)
     TValue *errfunc = restorestack(L, ef);
     TValue *top = L->top;
     lj_trace_abort(G(L));
-    if (!tvisfunc(errfunc) || L->status == LUA_ERRERR)
+    if (!tvisfunc(errfunc) || L->status == LUA_ERRERR) {
+      setstrV(L, top-1, lj_err_str(L, LJ_ERR_ERRERR));
       lj_err_throw(L, LUA_ERRERR);
+    }
     L->status = LUA_ERRERR;
     copyTV(L, top, top-1);
     copyTV(L, top-1, errfunc);
@@ -763,47 +954,3 @@ LUALIB_API int luaL_error(lua_State *L, const char *fmt, ...)
   return 0;  /* unreachable */
 }
 
-/* -- C++ exception support ----------------------------------------------- */
-
-#if defined(__ELF__) || defined(__MACH__)
-typedef enum
-{
-  _URC_NO_REASON,
-  _URC_FOREIGN_EXCEPTION_CAUGHT,
-  _URC_FATAL_PHASE2_ERROR,
-  _URC_FATAL_PHASE1_ERROR,
-  _URC_NORMAL_STOP,
-  _URC_END_OF_STACK,
-  _URC_HANDLER_FOUND,
-  _URC_INSTALL_CONTEXT,
-  _URC_CONTINUE_UNWIND
-} _Unwind_Reason_Code;
-
-#define _UA_SEARCH_PHASE        1
-#define _UA_CLEANUP_PHASE       2
-#define _UA_HANDLER_FRAME       4
-#define _UA_FORCE_UNWIND        8
-#define _UA_END_OF_STACK        16
-
-extern void *_Unwind_GetCFA(void *ctx);
-extern void _Unwind_DeleteException(void *uex);
-
-/* DWARF2 personality handler referenced from .eh_frame. */
-LJ_FUNCA int lj_err_unwind_dwarf(int version, int actions, uint64_t uexclass,
-                                 void *uex, void *ctx)
-{
-  if (version != 1)
-    return _URC_FATAL_PHASE1_ERROR;
-  UNUSED(uexclass);
-  if ((actions & _UA_SEARCH_PHASE))
-    return _URC_HANDLER_FOUND;
-  if ((actions & _UA_HANDLER_FRAME)) {
-    void *cf = _Unwind_GetCFA(ctx);
-    lua_State *L = cframe_L(cf);
-    _Unwind_DeleteException(uex);
-    lj_err_msg(L, LJ_ERR_ERRCPP);
-  }
-  return _URC_CONTINUE_UNWIND;
-}
-#endif
-