One Level Up Top Level

src/lj_err.c - luajit-2.0-src

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. ** Error handling.
  3. ** Copyright (C) 2005-2015 Mike Pall. See Copyright Notice in luajit.h
  4. */

  6. ‌#define lj_err_c
  7. ‌#define LUA_CORE

  9. #include "lj_obj.h"
  10. #include "lj_err.h"
  11. #include "lj_debug.h"
  12. #include "lj_str.h"
  13. #include "lj_func.h"
  14. #include "lj_state.h"
  15. #include "lj_frame.h"
  16. #include "lj_ff.h"
  17. #include "lj_trace.h"
  18. #include "lj_vm.h"
  19. #include "lj_strfmt.h"

  21. /*
  22. ** LuaJIT can either use internal or external frame unwinding:
  23. **
  24. ** - Internal frame unwinding (INT) is free-standing and doesn't require
  25. **   any OS or library support.
  26. **
  27. ** - External frame unwinding (EXT) uses the system-provided unwind handler.
  28. **
  29. ** Pros and Cons:
  30. **
  31. ** - EXT requires unwind tables for *all* functions on the C stack between
  32. **   the pcall/catch and the error/throw. This is the default on x64,
  33. **   but needs to be manually enabled on x86/PPC for non-C++ code.
  34. **
  35. ** - INT is faster when actually throwing errors (but this happens rarely).
  36. **   Setting up error handlers is zero-cost in any case.
  37. **
  38. ** - EXT provides full interoperability with C++ exceptions. You can throw
  39. **   Lua errors or C++ exceptions through a mix of Lua frames and C++ frames.
  40. **   C++ destructors are called as needed. C++ exceptions caught by pcall
  41. **   are converted to the string "C++ exception". Lua errors can be caught
  42. **   with catch (...) in C++.
  43. **
  44. ** - INT has only limited support for automatically catching C++ exceptions
  45. **   on POSIX systems using DWARF2 stack unwinding. Other systems may use
  46. **   the wrapper function feature. Lua errors thrown through C++ frames
  47. **   cannot be caught by C++ code and C++ destructors are not run.
  48. **
  49. ** EXT is the default on x64 systems, INT is the default on all other systems.
  50. **
  51. ** EXT can be manually enabled on POSIX systems using GCC and DWARF2 stack
  52. ** unwinding with -DLUAJIT_UNWIND_EXTERNAL. *All* C code must be compiled
  53. ** with -funwind-tables (or -fexceptions). This includes LuaJIT itself (set
  54. ** TARGET_CFLAGS), all of your C/Lua binding code, all loadable C modules
  55. ** and all C libraries that have callbacks which may be used to call back
  56. ** into Lua. C++ code must *not* be compiled with -fno-exceptions.
  57. **
  58. ** EXT cannot be enabled on WIN32 since system exceptions use code-driven SEH.
  59. ** EXT is mandatory on WIN64 since the calling convention has an abundance
  60. ** of callee-saved registers (rbx, rbp, rsi, rdi, r12-r15, xmm6-xmm15).
  61. ** EXT is mandatory on POSIX/x64 since the interpreter doesn't save r12/r13.
  62. */

  64. #if defined(__GNUC__) && (LJ_TARGET_X64 || defined(LUAJIT_UNWIND_EXTERNAL))
  65. ‌#define LJ_UNWIND_EXT        1
  66. #elif LJ_TARGET_X64 && LJ_TARGET_WINDOWS
  67. ‌#define LJ_UNWIND_EXT        1
  68. #endif

  70. /* -- Error messages ------------------------------------------------------ */

  72. /* Error message strings. */
  73. ‌LJ_DATADEF const char *lj_err_allmsg =
  74. ‌#define ERRDEF(name, msg)        msg "\0"
  75. #include "lj_errmsg.h"
  76. ;

  78. /* -- Internal frame unwinding -------------------------------------------- */

  80. /* Unwind Lua stack and move error message to new top. */
  81. ‌LJ_NOINLINE static void unwindstack(lua_State *L, TValue *top)
  82. {
  83.   lj_func_closeuv(L, top);
  84.   if (top < L->top-1) {
  85.     copyTV(L, top, L->top-1);
  86.     L->top = top+1;
  87.   }
  88.   lj_state_relimitstack(L);
  89. }

  91. /* Unwind until stop frame. Optionally cleanup frames. */
  92. ‌static void *err_unwind(lua_State *L, void *stopcf, int errcode)
  93. {
  94.   TValue *frame = L->base-1;
  95.   void *cf = L->cframe;
  96.   while (cf) {
  97.     int32_t nres = cframe_nres(cframe_raw(cf));
  98.     if (nres < 0) {  /* C frame without Lua frame? */
  99.       TValue *top = restorestack(L, -nres);
  100.       if (frame < top) {  /* Frame reached? */
  101.         if (errcode) {
  102.           L->base = frame+1;
  103.           L->cframe = cframe_prev(cf);
  104.           unwindstack(L, top);
  105.         }
  106.         return cf;
  107.       }
  108.     }
  109.     if (frame <= tvref(L->stack)+LJ_FR2)
  110.       break;
  111.     switch (frame_typep(frame)) {
  112.     case FRAME_LUA:  /* Lua frame. */
  113.     case FRAME_LUAP:
  114.       frame = frame_prevl(frame);
  115.       break;
  116.     case FRAME_C:  /* C frame. */
  117.     unwind_c:
  118. #if LJ_UNWIND_EXT
  119.       if (errcode) {
  120.         L->base = frame_prevd(frame) + 1;
  121.         L->cframe = cframe_prev(cf);
  122.         unwindstack(L, frame);
  123.       } else if (cf != stopcf) {
  124.         cf = cframe_prev(cf);
  125.         frame = frame_prevd(frame);
  126.         break;
  127.       }
  128.       return NULL;  /* Continue unwinding. */
  129. #else
  130.       UNUSED(stopcf);
  131.       cf = cframe_prev(cf);
  132.       frame = frame_prevd(frame);
  133.       break;
  134. #endif
  135.     case FRAME_CP:  /* Protected C frame. */
  136.       if (cframe_canyield(cf)) {  /* Resume? */
  137.         if (errcode) {
  138.           hook_leave(G(L));  /* Assumes nobody uses coroutines inside hooks. */
  139.           L->cframe = NULL;
  140.           L->status = (uint8_t)errcode;
  141.         }
  142.         return cf;
  143.       }
  144.       if (errcode) {
  145.         L->base = frame_prevd(frame) + 1;
  146.         L->cframe = cframe_prev(cf);
  147.         unwindstack(L, frame);
  148.       }
  149.       return cf;
  150.     case FRAME_CONT:  /* Continuation frame. */
  151.       if (frame_iscont_fficb(frame))
  152.         goto unwind_c;
  153.     case FRAME_VARG:  /* Vararg frame. */
  154.       frame = frame_prevd(frame);
  155.       break;
  156.     case FRAME_PCALL:  /* FF pcall() frame. */
  157.     case FRAME_PCALLH:  /* FF pcall() frame inside hook. */
  158.       if (errcode) {
  159.         if (errcode == LUA_YIELD) {
  160.           frame = frame_prevd(frame);
  161.           break;
  162.         }
  163.         if (frame_typep(frame) == FRAME_PCALL)
  164.           hook_leave(G(L));
  165.         L->base = frame_prevd(frame) + 1;
  166.         L->cframe = cf;
  167.         unwindstack(L, L->base);
  168.       }
  169.       return (void *)((intptr_t)cf | CFRAME_UNWIND_FF);
  170.     }
  171.   }
  172.   /* No C frame. */
  173.   if (errcode) {
  174.     L->base = tvref(L->stack)+1+LJ_FR2;
  175.     L->cframe = NULL;
  176.     unwindstack(L, L->base);
  177.     if (G(L)->panic)
  178.       G(L)->panic(L);
  179.     exit(EXIT_FAILURE);
  180.   }
  181.   return L;  /* Anything non-NULL will do. */
  182. }

  184. /* -- External frame unwinding -------------------------------------------- */

  186. #if defined(__GNUC__) && !LJ_NO_UNWIND && !LJ_TARGET_WINDOWS

  188. /*
  189. ** We have to use our own definitions instead of the mandatory (!) unwind.h,
  190. ** since various OS, distros and compilers mess up the header installation.
  191. */

  193. ‌typedef struct _Unwind_Exception
  194. {
  195.   uint64_t exclass;
  196.   void (*excleanup)(int, struct _Unwind_Exception *);
  197.   uintptr_t p1, p2;
  198. ‌} __attribute__((__aligned__)) _Unwind_Exception;

  200. ‌typedef struct _Unwind_Context _Unwind_Context;

  202. ‌#define _URC_OK                        0
  203. ‌#define _URC_FATAL_PHASE1_ERROR        3
  204. ‌#define _URC_HANDLER_FOUND        6
  205. ‌#define _URC_INSTALL_CONTEXT        7
  206. ‌#define _URC_CONTINUE_UNWIND        8
  207. ‌#define _URC_FAILURE                9

  209. #if !LJ_TARGET_ARM

  211. extern uintptr_t _Unwind_GetCFA(_Unwind_Context *);
  212. extern void _Unwind_SetGR(_Unwind_Context *, int, uintptr_t);
  213. extern void _Unwind_SetIP(_Unwind_Context *, uintptr_t);
  214. extern void _Unwind_DeleteException(_Unwind_Exception *);
  215. extern int _Unwind_RaiseException(_Unwind_Exception *);

  217. ‌#define _UA_SEARCH_PHASE        1
  218. ‌#define _UA_CLEANUP_PHASE        2
  219. ‌#define _UA_HANDLER_FRAME        4
  220. ‌#define _UA_FORCE_UNWIND        8

  222. ‌#define LJ_UEXCLASS                0x4c55414a49543200ULL        /* LUAJIT2\0 */
  223. ‌#define LJ_UEXCLASS_MAKE(c)        (LJ_UEXCLASS | (uint64_t)(c))
  224. ‌#define LJ_UEXCLASS_CHECK(cl)        (((cl) ^ LJ_UEXCLASS) <= 0xff)
  225. ‌#define LJ_UEXCLASS_ERRCODE(cl)        ((int)((cl) & 0xff))

  227. /* DWARF2 personality handler referenced from interpreter .eh_frame. */
  228. ‌LJ_FUNCA int lj_err_unwind_dwarf(int version, int actions,
  229.   uint64_t uexclass, _Unwind_Exception *uex, _Unwind_Context *ctx)
  230. {
  231.   void *cf;
  232.   lua_State *L;
  233.   if (version != 1)
  234.     return _URC_FATAL_PHASE1_ERROR;
  235.   UNUSED(uexclass);
  236.   cf = (void *)_Unwind_GetCFA(ctx);
  237.   L = cframe_L(cf);
  238.   if ((actions & _UA_SEARCH_PHASE)) {
  239. #if LJ_UNWIND_EXT
  240.     if (err_unwind(L, cf, 0) == NULL)
  241.       return _URC_CONTINUE_UNWIND;
  242. #endif
  243.     if (!LJ_UEXCLASS_CHECK(uexclass)) {
  244.       setstrV(L, L->top++, lj_err_str(L, LJ_ERR_ERRCPP));
  245.     }
  246.     return _URC_HANDLER_FOUND;
  247.   }
  248.   if ((actions & _UA_CLEANUP_PHASE)) {
  249.     int errcode;
  250.     if (LJ_UEXCLASS_CHECK(uexclass)) {
  251.       errcode = LJ_UEXCLASS_ERRCODE(uexclass);
  252.     } else {
  253.       if ((actions & _UA_HANDLER_FRAME))
  254.         _Unwind_DeleteException(uex);
  255.       errcode = LUA_ERRRUN;
  256.     }
  257. #if LJ_UNWIND_EXT
  258.     cf = err_unwind(L, cf, errcode);
  259.     if ((actions & _UA_FORCE_UNWIND)) {
  260.       return _URC_CONTINUE_UNWIND;
  261.     } else if (cf) {
  262.       _Unwind_SetGR(ctx, LJ_TARGET_EHRETREG, errcode);
  263.       _Unwind_SetIP(ctx, (uintptr_t)(cframe_unwind_ff(cf) ?
  264.                                      lj_vm_unwind_ff_eh :
  265.                                      lj_vm_unwind_c_eh));
  266.       return _URC_INSTALL_CONTEXT;
  267.     }
  268. #if LJ_TARGET_X86ORX64
  269.     else if ((actions & _UA_HANDLER_FRAME)) {
  270.       /* Workaround for ancient libgcc bug. Still present in RHEL 5.5. :-/
  271.       ** Real fix: http://gcc.gnu.org/viewcvs/trunk/gcc/unwind-dw2.c?r1=121165&r2=124837&pathrev=153877&diff_format=h
  272.       */
  273.       _Unwind_SetGR(ctx, LJ_TARGET_EHRETREG, errcode);
  274.       _Unwind_SetIP(ctx, (uintptr_t)lj_vm_unwind_rethrow);
  275.       return _URC_INSTALL_CONTEXT;
  276.     }
  277. #endif
  278. #else
  279.     /* This is not the proper way to escape from the unwinder. We get away with
  280.     ** it on non-x64 because the interpreter restores all callee-saved regs.
  281.     */
  282.     lj_err_throw(L, errcode);
  283. #endif
  284.   }
  285.   return _URC_CONTINUE_UNWIND;
  286. }

  288. #if LJ_UNWIND_EXT
  289. #if LJ_TARGET_OSX || defined(__OpenBSD__)
  290. /* Sorry, no thread safety for OSX. Complain to Apple, not me. */
  291. ‌static _Unwind_Exception static_uex;
  292. #else
  293. ‌static __thread _Unwind_Exception static_uex;
  294. #endif

  296. /* Raise DWARF2 exception. */
  297. ‌static void err_raise_ext(int errcode)
  298. {
  299.   static_uex.exclass = LJ_UEXCLASS_MAKE(errcode);
  300.   static_uex.excleanup = NULL;
  301.   _Unwind_RaiseException(&static_uex);
  302. }
  303. #endif

  305. #else

  307. extern void _Unwind_DeleteException(void *);
  308. extern int __gnu_unwind_frame (void *, _Unwind_Context *);
  309. extern int _Unwind_VRS_Set(_Unwind_Context *, int, uint32_t, int, void *);
  310. extern int _Unwind_VRS_Get(_Unwind_Context *, int, uint32_t, int, void *);

  312. ‌static inline uint32_t _Unwind_GetGR(_Unwind_Context *ctx, int r)
  313. {
  314.   uint32_t v;
  315.   _Unwind_VRS_Get(ctx, 0, r, 0, &v);
  316.   return v;
  317. }

  319. ‌static inline void _Unwind_SetGR(_Unwind_Context *ctx, int r, uint32_t v)
  320. {
  321.   _Unwind_VRS_Set(ctx, 0, r, 0, &v);
  322. }

  324. ‌#define _US_VIRTUAL_UNWIND_FRAME        0
  325. ‌#define _US_UNWIND_FRAME_STARTING        1
  326. ‌#define _US_ACTION_MASK                        3
  327. ‌#define _US_FORCE_UNWIND                8

  329. /* ARM unwinder personality handler referenced from interpreter .ARM.extab. */
  330. ‌LJ_FUNCA int lj_err_unwind_arm(int state, void *ucb, _Unwind_Context *ctx)
  331. {
  332.   void *cf = (void *)_Unwind_GetGR(ctx, 13);
  333.   lua_State *L = cframe_L(cf);
  334.   if ((state & _US_ACTION_MASK) == _US_VIRTUAL_UNWIND_FRAME) {
  335.     setstrV(L, L->top++, lj_err_str(L, LJ_ERR_ERRCPP));
  336.     return _URC_HANDLER_FOUND;
  337.   }
  338.   if ((state&(_US_ACTION_MASK|_US_FORCE_UNWIND)) == _US_UNWIND_FRAME_STARTING) {
  339.     _Unwind_DeleteException(ucb);
  340.     _Unwind_SetGR(ctx, 15, (uint32_t)(void *)lj_err_throw);
  341.     _Unwind_SetGR(ctx, 0, (uint32_t)L);
  342.     _Unwind_SetGR(ctx, 1, (uint32_t)LUA_ERRRUN);
  343.     return _URC_INSTALL_CONTEXT;
  344.   }
  345.   if (__gnu_unwind_frame(ucb, ctx) != _URC_OK)
  346.     return _URC_FAILURE;
  347.   return _URC_CONTINUE_UNWIND;
  348. }

  350. #endif

  352. #elif LJ_TARGET_X64 && LJ_TARGET_WINDOWS

  354. /*
  355. ** Someone in Redmond owes me several days of my life. A lot of this is
  356. ** undocumented or just plain wrong on MSDN. Some of it can be gathered
  357. ** from 3rd party docs or must be found by trial-and-error. They really
  358. ** don't want you to write your own language-specific exception handler
  359. ** or to interact gracefully with MSVC. :-(
  360. **
  361. ** Apparently MSVC doesn't call C++ destructors for foreign exceptions
  362. ** unless you compile your C++ code with /EHa. Unfortunately this means
  363. ** catch (...) also catches things like access violations. The use of
  364. ** _set_se_translator doesn't really help, because it requires /EHa, too.
  365. */

  367. ‌#define WIN32_LEAN_AND_MEAN
  368. #include <windows.h>

  370. /* Taken from: http://www.nynaeve.net/?p=99 */
  371. ‌typedef struct UndocumentedDispatcherContext {
  372.   ULONG64 ControlPc;
  373.   ULONG64 ImageBase;
  374.   PRUNTIME_FUNCTION FunctionEntry;
  375.   ULONG64 EstablisherFrame;
  376.   ULONG64 TargetIp;
  377.   PCONTEXT ContextRecord;
  378.   void (*LanguageHandler)(void);
  379.   PVOID HandlerData;
  380.   PUNWIND_HISTORY_TABLE HistoryTable;
  381.   ULONG ScopeIndex;
  382.   ULONG Fill0;
  383. ‌} UndocumentedDispatcherContext;

  385. /* Another wild guess. */
  386. extern void __DestructExceptionObject(EXCEPTION_RECORD *rec, int nothrow);

  388. #ifdef MINGW_SDK_INIT
  389. /* Workaround for broken MinGW64 declaration. */
  390. ‌VOID RtlUnwindEx_FIXED(PVOID,PVOID,PVOID,PVOID,PVOID,PVOID) asm("RtlUnwindEx");
  391. ‌#define RtlUnwindEx RtlUnwindEx_FIXED
  392. #endif

  394. ‌#define LJ_MSVC_EXCODE                ((DWORD)0xe06d7363)
  395. ‌#define LJ_GCC_EXCODE                ((DWORD)0x20474343)

  397. ‌#define LJ_EXCODE                ((DWORD)0xe24c4a00)
  398. ‌#define LJ_EXCODE_MAKE(c)        (LJ_EXCODE | (DWORD)(c))
  399. ‌#define LJ_EXCODE_CHECK(cl)        (((cl) ^ LJ_EXCODE) <= 0xff)
  400. ‌#define LJ_EXCODE_ERRCODE(cl)        ((int)((cl) & 0xff))

  402. /* Win64 exception handler for interpreter frame. */
  403. LJ_FUNCA EXCEPTION_DISPOSITION lj_err_unwind_win64(EXCEPTION_RECORD *rec,
  404.   void *cf, CONTEXT *ctx, UndocumentedDispatcherContext *dispatch)
  405. {
  406.   lua_State *L = cframe_L(cf);
  407.   int errcode = LJ_EXCODE_CHECK(rec->ExceptionCode) ?
  408.                 LJ_EXCODE_ERRCODE(rec->ExceptionCode) : LUA_ERRRUN;
  409.   if ((rec->ExceptionFlags & 6)) {  /* EH_UNWINDING|EH_EXIT_UNWIND */
  410.     /* Unwind internal frames. */
  411.     err_unwind(L, cf, errcode);
  412.   } else {
  413.     void *cf2 = err_unwind(L, cf, 0);
  414.     if (cf2) {  /* We catch it, so start unwinding the upper frames. */
  415.       if (rec->ExceptionCode == LJ_MSVC_EXCODE ||
  416.           rec->ExceptionCode == LJ_GCC_EXCODE) {
  417.         __DestructExceptionObject(rec, 1);
  418.         setstrV(L, L->top++, lj_err_str(L, LJ_ERR_ERRCPP));
  419.       } else if (!LJ_EXCODE_CHECK(rec->ExceptionCode)) {
  420.         /* Don't catch access violations etc. */
  421.         return ExceptionContinueSearch;
  422.       }
  423.       /* Unwind the stack and call all handlers for all lower C frames
  424.       ** (including ourselves) again with EH_UNWINDING set. Then set
  425.       ** rsp = cf, rax = errcode and jump to the specified target.
  426.       */
  427.       RtlUnwindEx(cf, (void *)((cframe_unwind_ff(cf2) && errcode != LUA_YIELD) ?
  428.                                lj_vm_unwind_ff_eh :
  429.                                lj_vm_unwind_c_eh),
  430.                   rec, (void *)(uintptr_t)errcode, ctx, dispatch->HistoryTable);
  431.       /* RtlUnwindEx should never return. */
  432.     }
  433.   }
  434.   return ExceptionContinueSearch;
  435. }

  437. /* Raise Windows exception. */
  438. ‌static void err_raise_ext(int errcode)
  439. {
  440.   RaiseException(LJ_EXCODE_MAKE(errcode), 1 /* EH_NONCONTINUABLE */, 0, NULL);
  441. }

  443. #endif

  445. /* -- Error handling ------------------------------------------------------ */

  447. /* Throw error. Find catch frame, unwind stack and continue. */
  448. ‌LJ_NOINLINE void LJ_FASTCALL lj_err_throw(lua_State *L, int errcode)
  449. {
  450.   global_State *g = G(L);
  451.   lj_trace_abort(g);
  452.   setmref(g->jit_base, NULL);
  453.   L->status = 0;
  454. #if LJ_UNWIND_EXT
  455.   err_raise_ext(errcode);
  456.   /*
  457.   ** A return from this function signals a corrupt C stack that cannot be
  458.   ** unwound. We have no choice but to call the panic function and exit.
  459.   **
  460.   ** Usually this is caused by a C function without unwind information.
  461.   ** This should never happen on x64, but may happen if you've manually
  462.   ** enabled LUAJIT_UNWIND_EXTERNAL and forgot to recompile *every*
  463.   ** non-C++ file with -funwind-tables.
  464.   */
  465.   if (G(L)->panic)
  466.     G(L)->panic(L);
  467. #else
  468.   {
  469.     void *cf = err_unwind(L, NULL, errcode);
  470.     if (cframe_unwind_ff(cf))
  471.       lj_vm_unwind_ff(cframe_raw(cf));
  472.     else
  473.       lj_vm_unwind_c(cframe_raw(cf), errcode);
  474.   }
  475. #endif
  476.   exit(EXIT_FAILURE);
  477. }

  479. /* Return string object for error message. */
  480. ‌LJ_NOINLINE GCstr *lj_err_str(lua_State *L, ErrMsg em)
  481. {
  482.   return lj_str_newz(L, err2msg(em));
  483. }

  485. /* Out-of-memory error. */
  486. ‌LJ_NOINLINE void lj_err_mem(lua_State *L)
  487. {
  488.   if (L->status == LUA_ERRERR+1)  /* Don't touch the stack during lua_open. */
  489.     lj_vm_unwind_c(L->cframe, LUA_ERRMEM);
  490.   setstrV(L, L->top++, lj_err_str(L, LJ_ERR_ERRMEM));
  491.   lj_err_throw(L, LUA_ERRMEM);
  492. }

  494. /* Find error function for runtime errors. Requires an extra stack traversal. */
  495. ‌static ptrdiff_t finderrfunc(lua_State *L)
  496. {
  497.   cTValue *frame = L->base-1, *bot = tvref(L->stack)+LJ_FR2;
  498.   void *cf = L->cframe;
  499.   while (frame > bot && cf) {
  500.     while (cframe_nres(cframe_raw(cf)) < 0) {  /* cframe without frame? */
  501.       if (frame >= restorestack(L, -cframe_nres(cf)))
  502.         break;
  503.       if (cframe_errfunc(cf) >= 0)  /* Error handler not inherited (-1)? */
  504.         return cframe_errfunc(cf);
  505.       cf = cframe_prev(cf);  /* Else unwind cframe and continue searching. */
  506.       if (cf == NULL)
  507.         return 0;
  508.     }
  509.     switch (frame_typep(frame)) {
  510.     case FRAME_LUA:
  511.     case FRAME_LUAP:
  512.       frame = frame_prevl(frame);
  513.       break;
  514.     case FRAME_C:
  515.       cf = cframe_prev(cf);
  516.       /* fallthrough */
  517.     case FRAME_VARG:
  518.       frame = frame_prevd(frame);
  519.       break;
  520.     case FRAME_CONT:
  521.       if (frame_iscont_fficb(frame))
  522.         cf = cframe_prev(cf);
  523.       frame = frame_prevd(frame);
  524.       break;
  525.     case FRAME_CP:
  526.       if (cframe_canyield(cf)) return 0;
  527.       if (cframe_errfunc(cf) >= 0)
  528.         return cframe_errfunc(cf);
  529.       frame = frame_prevd(frame);
  530.       break;
  531.     case FRAME_PCALL:
  532.     case FRAME_PCALLH:
  533.       if (frame_func(frame_prevd(frame))->c.ffid == FF_xpcall)
  534.         return savestack(L, frame_prevd(frame)+1);  /* xpcall's errorfunc. */
  535.       return 0;
  536.     default:
  537.       lua_assert(0);
  538.       return 0;
  539.     }
  540.   }
  541.   return 0;
  542. }

  544. /* Runtime error. */
  545. ‌LJ_NOINLINE void lj_err_run(lua_State *L)
  546. {
  547.   ptrdiff_t ef = finderrfunc(L);
  548.   if (ef) {
  549.     TValue *errfunc = restorestack(L, ef);
  550.     TValue *top = L->top;
  551.     lj_trace_abort(G(L));
  552.     if (!tvisfunc(errfunc) || L->status == LUA_ERRERR) {
  553.       setstrV(L, top-1, lj_err_str(L, LJ_ERR_ERRERR));
  554.       lj_err_throw(L, LUA_ERRERR);
  555.     }
  556.     L->status = LUA_ERRERR;
  557.     copyTV(L, top+LJ_FR2, top-1);
  558.     copyTV(L, top-1, errfunc);
  559.     if (LJ_FR2) setnilV(top++);
  560.     L->top = top+1;
  561.     lj_vm_call(L, top, 1+1);  /* Stack: |errfunc|msg| -> |msg| */
  562.   }
  563.   lj_err_throw(L, LUA_ERRRUN);
  564. }

  566. /* Formatted runtime error message. */
  567. ‌LJ_NORET LJ_NOINLINE static void err_msgv(lua_State *L, ErrMsg em, ...)
  568. {
  569.   const char *msg;
  570.   va_list argp;
  571.   va_start(argp, em);
  572.   if (curr_funcisL(L)) L->top = curr_topL(L);
  573.   msg = lj_strfmt_pushvf(L, err2msg(em), argp);
  574.   va_end(argp);
  575.   lj_debug_addloc(L, msg, L->base-1, NULL);
  576.   lj_err_run(L);
  577. }

  579. /* Non-vararg variant for better calling conventions. */
  580. ‌LJ_NOINLINE void lj_err_msg(lua_State *L, ErrMsg em)
  581. {
  582.   err_msgv(L, em);
  583. }

  585. /* Lexer error. */
  586. ‌LJ_NOINLINE void lj_err_lex(lua_State *L, GCstr *src, const char *tok,
  587.                             BCLine line, ErrMsg em, va_list argp)
  588. {
  589.   char buff[LUA_IDSIZE];
  590.   const char *msg;
  591.   lj_debug_shortname(buff, src, line);
  592.   msg = lj_strfmt_pushvf(L, err2msg(em), argp);
  593.   msg = lj_strfmt_pushf(L, "%s:%d: %s", buff, line, msg);
  594.   if (tok)
  595.     lj_strfmt_pushf(L, err2msg(LJ_ERR_XNEAR), msg, tok);
  596.   lj_err_throw(L, LUA_ERRSYNTAX);
  597. }

  599. /* Typecheck error for operands. */
  600. ‌LJ_NOINLINE void lj_err_optype(lua_State *L, cTValue *o, ErrMsg opm)
  601. {
  602.   const char *tname = lj_typename(o);
  603.   const char *opname = err2msg(opm);
  604.   if (curr_funcisL(L)) {
  605.     GCproto *pt = curr_proto(L);
  606.     const BCIns *pc = cframe_Lpc(L) - 1;
  607.     const char *oname = NULL;
  608.     const char *kind = lj_debug_slotname(pt, pc, (BCReg)(o-L->base), &oname);
  609.     if (kind)
  610.       err_msgv(L, LJ_ERR_BADOPRT, opname, kind, oname, tname);
  611.   }
  612.   err_msgv(L, LJ_ERR_BADOPRV, opname, tname);
  613. }

  615. /* Typecheck error for ordered comparisons. */
  616. ‌LJ_NOINLINE void lj_err_comp(lua_State *L, cTValue *o1, cTValue *o2)
  617. {
  618.   const char *t1 = lj_typename(o1);
  619.   const char *t2 = lj_typename(o2);
  620.   err_msgv(L, t1 == t2 ? LJ_ERR_BADCMPV : LJ_ERR_BADCMPT, t1, t2);
  621.   /* This assumes the two "boolean" entries are commoned by the C compiler. */
  622. }

  624. /* Typecheck error for __call. */
  625. ‌LJ_NOINLINE void lj_err_optype_call(lua_State *L, TValue *o)
  626. {
  627.   /* Gross hack if lua_[p]call or pcall/xpcall fail for a non-callable object:
  628.   ** L->base still points to the caller. So add a dummy frame with L instead
  629.   ** of a function. See lua_getstack().
  630.   */
  631.   const BCIns *pc = cframe_Lpc(L);
  632.   if (((ptrdiff_t)pc & FRAME_TYPE) != FRAME_LUA) {
  633.     const char *tname = lj_typename(o);
  634.     if (LJ_FR2) o++;
  635.     setframe_pc(o, pc);
  636.     setframe_gc(o, obj2gco(L), LJ_TTHREAD);
  637.     L->top = L->base = o+1;
  638.     err_msgv(L, LJ_ERR_BADCALL, tname);
  639.   }
  640.   lj_err_optype(L, o, LJ_ERR_OPCALL);
  641. }

  643. /* Error in context of caller. */
  644. ‌LJ_NOINLINE void lj_err_callermsg(lua_State *L, const char *msg)
  645. {
  646.   TValue *frame = L->base-1;
  647.   TValue *pframe = NULL;
  648.   if (frame_islua(frame)) {
  649.     pframe = frame_prevl(frame);
  650.   } else if (frame_iscont(frame)) {
  651.     if (frame_iscont_fficb(frame)) {
  652.       pframe = frame;
  653.       frame = NULL;
  654.     } else {
  655.       pframe = frame_prevd(frame);
  656. #if LJ_HASFFI
  657.       /* Remove frame for FFI metamethods. */
  658.       if (frame_func(frame)->c.ffid >= FF_ffi_meta___index &&
  659.           frame_func(frame)->c.ffid <= FF_ffi_meta___tostring) {
  660.         L->base = pframe+1;
  661.         L->top = frame;
  662.         setcframe_pc(cframe_raw(L->cframe), frame_contpc(frame));
  663.       }
  664. #endif
  665.     }
  666.   }
  667.   lj_debug_addloc(L, msg, pframe, frame);
  668.   lj_err_run(L);
  669. }

  671. /* Formatted error in context of caller. */
  672. ‌LJ_NOINLINE void lj_err_callerv(lua_State *L, ErrMsg em, ...)
  673. {
  674.   const char *msg;
  675.   va_list argp;
  676.   va_start(argp, em);
  677.   msg = lj_strfmt_pushvf(L, err2msg(em), argp);
  678.   va_end(argp);
  679.   lj_err_callermsg(L, msg);
  680. }

  682. /* Error in context of caller. */
  683. ‌LJ_NOINLINE void lj_err_caller(lua_State *L, ErrMsg em)
  684. {
  685.   lj_err_callermsg(L, err2msg(em));
  686. }

  688. /* Argument error message. */
  689. ‌LJ_NORET LJ_NOINLINE static void err_argmsg(lua_State *L, int narg,
  690.                                             const char *msg)
  691. {
  692.   const char *fname = "?";
  693.   const char *ftype = lj_debug_funcname(L, L->base - 1, &fname);
  694.   if (narg < 0 && narg > LUA_REGISTRYINDEX)
  695.     narg = (int)(L->top - L->base) + narg + 1;
  696.   if (ftype && ftype[3] == 'h' && --narg == 0)  /* Check for "method". */
  697.     msg = lj_strfmt_pushf(L, err2msg(LJ_ERR_BADSELF), fname, msg);
  698.   else
  699.     msg = lj_strfmt_pushf(L, err2msg(LJ_ERR_BADARG), narg, fname, msg);
  700.   lj_err_callermsg(L, msg);
  701. }

  703. /* Formatted argument error. */
  704. ‌LJ_NOINLINE void lj_err_argv(lua_State *L, int narg, ErrMsg em, ...)
  705. {
  706.   const char *msg;
  707.   va_list argp;
  708.   va_start(argp, em);
  709.   msg = lj_strfmt_pushvf(L, err2msg(em), argp);
  710.   va_end(argp);
  711.   err_argmsg(L, narg, msg);
  712. }

  714. /* Argument error. */
  715. ‌LJ_NOINLINE void lj_err_arg(lua_State *L, int narg, ErrMsg em)
  716. {
  717.   err_argmsg(L, narg, err2msg(em));
  718. }

  720. /* Typecheck error for arguments. */
  721. ‌LJ_NOINLINE void lj_err_argtype(lua_State *L, int narg, const char *xname)
  722. {
  723.   const char *tname, *msg;
  724.   if (narg <= LUA_REGISTRYINDEX) {
  725.     if (narg >= LUA_GLOBALSINDEX) {
  726.       tname = lj_obj_itypename[~LJ_TTAB];
  727.     } else {
  728.       GCfunc *fn = curr_func(L);
  729.       int idx = LUA_GLOBALSINDEX - narg;
  730.       if (idx <= fn->c.nupvalues)
  731.         tname = lj_typename(&fn->c.upvalue[idx-1]);
  732.       else
  733.         tname = lj_obj_typename[0];
  734.     }
  735.   } else {
  736.     TValue *o = narg < 0 ? L->top + narg : L->base + narg-1;
  737.     tname = o < L->top ? lj_typename(o) : lj_obj_typename[0];
  738.   }
  739.   msg = lj_strfmt_pushf(L, err2msg(LJ_ERR_BADTYPE), xname, tname);
  740.   err_argmsg(L, narg, msg);
  741. }

  743. /* Typecheck error for arguments. */
  744. ‌LJ_NOINLINE void lj_err_argt(lua_State *L, int narg, int tt)
  745. {
  746.   lj_err_argtype(L, narg, lj_obj_typename[tt+1]);
  747. }

  749. /* -- Public error handling API ------------------------------------------- */

  751. ‌LUA_API lua_CFunction lua_atpanic(lua_State *L, lua_CFunction panicf)
  752. {
  753.   lua_CFunction old = G(L)->panic;
  754.   G(L)->panic = panicf;
  755.   return old;
  756. }

  758. /* Forwarders for the public API (C calling convention and no LJ_NORET). */
  759. ‌LUA_API int lua_error(lua_State *L)
  760. {
  761.   lj_err_run(L);
  762.   return 0;  /* unreachable */
  763. }

  765. ‌LUALIB_API int luaL_argerror(lua_State *L, int narg, const char *msg)
  766. {
  767.   err_argmsg(L, narg, msg);
  768.   return 0;  /* unreachable */
  769. }

  771. ‌LUALIB_API int luaL_typerror(lua_State *L, int narg, const char *xname)
  772. {
  773.   lj_err_argtype(L, narg, xname);
  774.   return 0;  /* unreachable */
  775. }

  777. ‌LUALIB_API void luaL_where(lua_State *L, int level)
  778. {
  779.   int size;
  780.   cTValue *frame = lj_debug_frame(L, level, &size);
  781.   lj_debug_addloc(L, "", frame, size ? frame+size : NULL);
  782. }

  784. ‌LUALIB_API int luaL_error(lua_State *L, const char *fmt, ...)
  785. {
  786.   const char *msg;
  787.   va_list argp;
  788.   va_start(argp, fmt);
  789.   msg = lj_strfmt_pushvf(L, fmt, argp);
  790.   va_end(argp);
  791.   lj_err_callermsg(L, msg);
  792.   return 0;  /* unreachable */
  793. }

One Level Up Top Level