src/lj_err.c

   1 /*
   2 ** Error handling.
   3 ** Copyright (C) 2005-2023 Mike Pall. See Copyright Notice in luajit.h
   4 */
   5
   6 #define lj_err_c
   7 #define LUA_CORE
   8
   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"
  20
  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. C modules used by Lua code can
  33 **   throw errors, so these need to have unwind tables, too. Transitively
  34 **   this applies to all system libraries used by C modules -- at least
  35 **   when they have callbacks which may throw an error.
  36 **
  37 ** - INT is faster when actually throwing errors, but this happens rarely.
  38 **   Setting up error handlers is zero-cost in any case.
  39 **
  40 ** - INT needs to save *all* callee-saved registers when entering the
  41 **   interpreter. EXT only needs to save those actually used inside the
  42 **   interpreter. JIT-compiled code may need to save some more.
  43 **
  44 ** - EXT provides full interoperability with C++ exceptions. You can throw
  45 **   Lua errors or C++ exceptions through a mix of Lua frames and C++ frames.
  46 **   C++ destructors are called as needed. C++ exceptions caught by pcall
  47 **   are converted to the string "C++ exception". Lua errors can be caught
  48 **   with catch (...) in C++.
  49 **
  50 ** - INT has only limited support for automatically catching C++ exceptions
  51 **   on POSIX systems using DWARF2 stack unwinding. Other systems may use
  52 **   the wrapper function feature. Lua errors thrown through C++ frames
  53 **   cannot be caught by C++ code and C++ destructors are not run.
  54 **
  55 ** - EXT can handle errors from internal helper functions that are called
  56 **   from JIT-compiled code (except for Windows/x86 and 32 bit ARM).
  57 **   INT has no choice but to call the panic handler, if this happens.
  58 **   Note: this is mainly relevant for out-of-memory errors.
  59 **
  60 ** EXT is the default on all systems where the toolchain produces unwind
  61 ** tables by default (*). This is hard-coded and/or detected in src/Makefile.
  62 ** You can thwart the detection with: TARGET_XCFLAGS=-DLUAJIT_UNWIND_INTERNAL
  63 **
  64 ** INT is the default on all other systems.
  65 **
  66 ** EXT can be manually enabled for toolchains that are able to produce
  67 ** conforming unwind tables:
  68 **   "TARGET_XCFLAGS=-funwind-tables -DLUAJIT_UNWIND_EXTERNAL"
  69 ** As explained above, *all* C code used directly or indirectly by LuaJIT
  70 ** must be compiled with -funwind-tables (or -fexceptions). C++ code must
  71 ** *not* be compiled with -fno-exceptions.
  72 **
  73 ** If you're unsure whether error handling inside the VM works correctly,
  74 ** try running this and check whether it prints "OK":
  75 **
  76 **   luajit -e "print(select(2, load('OK')):match('OK'))"
  77 **
  78 ** (*) Originally, toolchains only generated unwind tables for C++ code. For
  79 ** interoperability reasons, this can be manually enabled for plain C code,
  80 ** too (with -funwind-tables). With the introduction of the x64 architecture,
  81 ** the corresponding POSIX and Windows ABIs mandated unwind tables for all
  82 ** code. Over the following years most desktop and server platforms have
  83 ** enabled unwind tables by default on all architectures. OTOH mobile and
  84 ** embedded platforms do not consistently mandate unwind tables.
  85 */
  86
  87 /* -- Error messages ------------------------------------------------------ */
  88
  89 /* Error message strings. */
  90 LJ_DATADEF const char *lj_err_allmsg =
  91 #define ERRDEF(name, msg)       msg "\0"
  92 #include "lj_errmsg.h"
  93 ;
  94
  95 /* -- Internal frame unwinding -------------------------------------------- */
  96
  97 /* Unwind Lua stack and move error message to new top. */
  98 LJ_NOINLINE static void unwindstack(lua_State *L, TValue *top)
  99 {
 100   lj_func_closeuv(L, top);
 101   if (top < L->top-1) {
 102     copyTV(L, top, L->top-1);
 103     L->top = top+1;
 104   }
 105   lj_state_relimitstack(L);
 106 }
 107
 108 /* Unwind until stop frame. Optionally cleanup frames. */
 109 static void *err_unwind(lua_State *L, void *stopcf, int errcode)
 110 {
 111   TValue *frame = L->base-1;
 112   void *cf = L->cframe;
 113   while (cf) {
 114     int32_t nres = cframe_nres(cframe_raw(cf));
 115     if (nres < 0) {  /* C frame without Lua frame? */
 116       TValue *top = restorestack(L, -nres);
 117       if (frame < top) {  /* Frame reached? */
 118         if (errcode) {
 119           L->base = frame+1;
 120           L->cframe = cframe_prev(cf);
 121           unwindstack(L, top);
 122         }
 123         return cf;
 124       }
 125     }
 126     if (frame <= tvref(L->stack)+LJ_FR2)
 127       break;
 128     switch (frame_typep(frame)) {
 129     case FRAME_LUA:  /* Lua frame. */
 130     case FRAME_LUAP:
 131       frame = frame_prevl(frame);
 132       break;
 133     case FRAME_C:  /* C frame. */
 134     unwind_c:
 135 #if LJ_UNWIND_EXT
 136       if (errcode) {
 137         L->base = frame_prevd(frame) + 1;
 138         L->cframe = cframe_prev(cf);
 139         unwindstack(L, frame - LJ_FR2);
 140       } else if (cf != stopcf) {
 141         cf = cframe_prev(cf);
 142         frame = frame_prevd(frame);
 143         break;
 144       }
 145       return NULL;  /* Continue unwinding. */
 146 #else
 147       UNUSED(stopcf);
 148       cf = cframe_prev(cf);
 149       frame = frame_prevd(frame);
 150       break;
 151 #endif
 152     case FRAME_CP:  /* Protected C frame. */
 153       if (cframe_canyield(cf)) {  /* Resume? */
 154         if (errcode) {
 155           hook_leave(G(L));  /* Assumes nobody uses coroutines inside hooks. */
 156           L->cframe = NULL;
 157           L->status = (uint8_t)errcode;
 158         }
 159         return cf;
 160       }
 161       if (errcode) {
 162         L->base = frame_prevd(frame) + 1;
 163         L->cframe = cframe_prev(cf);
 164         unwindstack(L, frame - LJ_FR2);
 165       }
 166       return cf;
 167     case FRAME_CONT:  /* Continuation frame. */
 168       if (frame_iscont_fficb(frame))
 169         goto unwind_c;
 170       /* fallthrough */
 171     case FRAME_VARG:  /* Vararg frame. */
 172       frame = frame_prevd(frame);
 173       break;
 174     case FRAME_PCALL:  /* FF pcall() frame. */
 175     case FRAME_PCALLH:  /* FF pcall() frame inside hook. */
 176       if (errcode) {
 177         global_State *g;
 178         if (errcode == LUA_YIELD) {
 179           frame = frame_prevd(frame);
 180           break;
 181         }
 182         g = G(L);
 183         setgcref(g->cur_L, obj2gco(L));
 184         if (frame_typep(frame) == FRAME_PCALL)
 185           hook_leave(g);
 186         L->base = frame_prevd(frame) + 1;
 187         L->cframe = cf;
 188         unwindstack(L, L->base);
 189       }
 190       return (void *)((intptr_t)cf | CFRAME_UNWIND_FF);
 191     }
 192   }
 193   /* No C frame. */
 194   if (errcode) {
 195     L->base = tvref(L->stack)+1+LJ_FR2;
 196     L->cframe = NULL;
 197     unwindstack(L, L->base);
 198     if (G(L)->panic)
 199       G(L)->panic(L);
 200     exit(EXIT_FAILURE);
 201   }
 202   return L;  /* Anything non-NULL will do. */
 203 }
 204
 205 /* -- External frame unwinding -------------------------------------------- */
 206
 207 #if LJ_ABI_WIN
 208
 209 /*
 210 ** Someone in Redmond owes me several days of my life. A lot of this is
 211 ** undocumented or just plain wrong on MSDN. Some of it can be gathered
 212 ** from 3rd party docs or must be found by trial-and-error. They really
 213 ** don't want you to write your own language-specific exception handler
 214 ** or to interact gracefully with MSVC. :-(
 215 */
 216
 217 #define WIN32_LEAN_AND_MEAN
 218 #include <windows.h>
 219
 220 #if LJ_TARGET_X86
 221 typedef void *UndocumentedDispatcherContext;  /* Unused on x86. */
 222 #else
 223 /* Taken from: http://www.nynaeve.net/?p=99 */
 224 typedef struct UndocumentedDispatcherContext {
 225   ULONG64 ControlPc;
 226   ULONG64 ImageBase;
 227   PRUNTIME_FUNCTION FunctionEntry;
 228   ULONG64 EstablisherFrame;
 229   ULONG64 TargetIp;
 230   PCONTEXT ContextRecord;
 231   void (*LanguageHandler)(void);
 232   PVOID HandlerData;
 233   PUNWIND_HISTORY_TABLE HistoryTable;
 234   ULONG ScopeIndex;
 235   ULONG Fill0;
 236 } UndocumentedDispatcherContext;
 237 #endif
 238
 239 /* Another wild guess. */
 240 extern void __DestructExceptionObject(EXCEPTION_RECORD *rec, int nothrow);
 241
 242 #if LJ_TARGET_X64 && defined(MINGW_SDK_INIT)
 243 /* Workaround for broken MinGW64 declaration. */
 244 VOID RtlUnwindEx_FIXED(PVOID,PVOID,PVOID,PVOID,PVOID,PVOID) asm("RtlUnwindEx");
 245 #define RtlUnwindEx RtlUnwindEx_FIXED
 246 #endif
 247
 248 #define LJ_MSVC_EXCODE          ((DWORD)0xe06d7363)
 249 #define LJ_GCC_EXCODE           ((DWORD)0x20474343)
 250
 251 #define LJ_EXCODE               ((DWORD)0xe24c4a00)
 252 #define LJ_EXCODE_MAKE(c)       (LJ_EXCODE | (DWORD)(c))
 253 #define LJ_EXCODE_CHECK(cl)     (((cl) ^ LJ_EXCODE) <= 0xff)
 254 #define LJ_EXCODE_ERRCODE(cl)   ((int)((cl) & 0xff))
 255
 256 /* Windows exception handler for interpreter frame. */
 257 LJ_FUNCA int lj_err_unwind_win(EXCEPTION_RECORD *rec,
 258   void *f, CONTEXT *ctx, UndocumentedDispatcherContext *dispatch)
 259 {
 260 #if LJ_TARGET_X86
 261   void *cf = (char *)f - CFRAME_OFS_SEH;
 262 #elif LJ_TARGET_ARM64
 263   void *cf = (char *)f - CFRAME_SIZE;
 264 #else
 265   void *cf = f;
 266 #endif
 267   lua_State *L = cframe_L(cf);
 268   int errcode = LJ_EXCODE_CHECK(rec->ExceptionCode) ?
 269                 LJ_EXCODE_ERRCODE(rec->ExceptionCode) : LUA_ERRRUN;
 270   if ((rec->ExceptionFlags & 6)) {  /* EH_UNWINDING|EH_EXIT_UNWIND */
 271     if (rec->ExceptionCode == STATUS_LONGJUMP &&
 272         rec->ExceptionRecord &&
 273         LJ_EXCODE_CHECK(rec->ExceptionRecord->ExceptionCode)) {
 274       errcode = LJ_EXCODE_ERRCODE(rec->ExceptionRecord->ExceptionCode);
 275       if ((rec->ExceptionFlags & 0x20)) {  /* EH_TARGET_UNWIND */
 276         /* Unwinding is about to finish; revert the ExceptionCode so that
 277         ** RtlRestoreContext does not try to restore from a _JUMP_BUFFER.
 278         */
 279         rec->ExceptionCode = 0;
 280       }
 281     }
 282     /* Unwind internal frames. */
 283     err_unwind(L, cf, errcode);
 284   } else {
 285     void *cf2 = err_unwind(L, cf, 0);
 286     if (cf2) {  /* We catch it, so start unwinding the upper frames. */
 287 #if !LJ_TARGET_X86
 288       EXCEPTION_RECORD rec2;
 289 #endif
 290       if (rec->ExceptionCode == LJ_MSVC_EXCODE ||
 291           rec->ExceptionCode == LJ_GCC_EXCODE) {
 292 #if !LJ_TARGET_CYGWIN
 293         __DestructExceptionObject(rec, 1);
 294 #endif
 295         setstrV(L, L->top++, lj_err_str(L, LJ_ERR_ERRCPP));
 296       } else if (!LJ_EXCODE_CHECK(rec->ExceptionCode)) {
 297         /* Don't catch access violations etc. */
 298         return 1;  /* ExceptionContinueSearch */
 299       }
 300 #if LJ_TARGET_X86
 301       UNUSED(ctx);
 302       UNUSED(dispatch);
 303       /* Call all handlers for all lower C frames (including ourselves) again
 304       ** with EH_UNWINDING set. Then call the specified function, passing cf
 305       ** and errcode.
 306       */
 307       lj_vm_rtlunwind(cf, (void *)rec,
 308         (cframe_unwind_ff(cf2) && errcode != LUA_YIELD) ?
 309         (void *)lj_vm_unwind_ff : (void *)lj_vm_unwind_c, errcode);
 310       /* lj_vm_rtlunwind does not return. */
 311 #else
 312       if (LJ_EXCODE_CHECK(rec->ExceptionCode)) {
 313         /* For unwind purposes, wrap the EXCEPTION_RECORD in something that
 314         ** looks like a longjmp, so that MSVC will execute C++ destructors in
 315         ** the frames we unwind over. ExceptionInformation[0] should really
 316         ** contain a _JUMP_BUFFER*, but hopefully nobody is looking too closely
 317         ** at this point.
 318         */
 319         rec2.ExceptionCode = STATUS_LONGJUMP;
 320         rec2.ExceptionRecord = rec;
 321         rec2.ExceptionAddress = 0;
 322         rec2.NumberParameters = 1;
 323         rec2.ExceptionInformation[0] = (ULONG_PTR)ctx;
 324         rec = &rec2;
 325       }
 326       /* Unwind the stack and call all handlers for all lower C frames
 327       ** (including ourselves) again with EH_UNWINDING set. Then set
 328       ** stack pointer = f, result = errcode and jump to the specified target.
 329       */
 330       RtlUnwindEx(f, (void *)((cframe_unwind_ff(cf2) && errcode != LUA_YIELD) ?
 331                               lj_vm_unwind_ff_eh :
 332                               lj_vm_unwind_c_eh),
 333                   rec, (void *)(uintptr_t)errcode, dispatch->ContextRecord,
 334                   dispatch->HistoryTable);
 335       /* RtlUnwindEx should never return. */
 336 #endif
 337     }
 338   }
 339   return 1;  /* ExceptionContinueSearch */
 340 }
 341
 342 #if LJ_UNWIND_JIT
 343
 344 #if LJ_TARGET_X64
 345 #define CONTEXT_REG_PC  Rip
 346 #elif LJ_TARGET_ARM64
 347 #define CONTEXT_REG_PC  Pc
 348 #else
 349 #error "NYI: Windows arch-specific unwinder for JIT-compiled code"
 350 #endif
 351
 352 /* Windows unwinder for JIT-compiled code. */
 353 static void err_unwind_win_jit(global_State *g, int errcode)
 354 {
 355   CONTEXT ctx;
 356   UNWIND_HISTORY_TABLE hist;
 357
 358   memset(&hist, 0, sizeof(hist));
 359   RtlCaptureContext(&ctx);
 360   while (1) {
 361     DWORD64 frame, base, addr = ctx.CONTEXT_REG_PC;
 362     void *hdata;
 363     PRUNTIME_FUNCTION func = RtlLookupFunctionEntry(addr, &base, &hist);
 364     if (!func) {  /* Found frame without .pdata: must be JIT-compiled code. */
 365       ExitNo exitno;
 366       uintptr_t stub = lj_trace_unwind(G2J(g), (uintptr_t)(addr - sizeof(MCode)), &exitno);
 367       if (stub) {  /* Jump to side exit to unwind the trace. */
 368         ctx.CONTEXT_REG_PC = stub;
 369         G2J(g)->exitcode = errcode;
 370         RtlRestoreContext(&ctx, NULL);  /* Does not return. */
 371       }
 372       break;
 373     }
 374     RtlVirtualUnwind(UNW_FLAG_NHANDLER, base, addr, func,
 375                      &ctx, &hdata, &frame, NULL);
 376     if (!addr) break;
 377   }
 378   /* Unwinding failed, if we end up here. */
 379 }
 380 #endif
 381
 382 /* Raise Windows exception. */
 383 static void err_raise_ext(global_State *g, int errcode)
 384 {
 385 #if LJ_UNWIND_JIT
 386   if (tvref(g->jit_base)) {
 387     err_unwind_win_jit(g, errcode);
 388     return;  /* Unwinding failed. */
 389   }
 390 #elif LJ_HASJIT
 391   /* Cannot catch on-trace errors for Windows/x86 SEH. Unwind to interpreter. */
 392   setmref(g->jit_base, NULL);
 393 #endif
 394   UNUSED(g);
 395   RaiseException(LJ_EXCODE_MAKE(errcode), 1 /* EH_NONCONTINUABLE */, 0, NULL);
 396 }
 397
 398 #elif !LJ_NO_UNWIND && (defined(__GNUC__) || defined(__clang__))
 399
 400 /*
 401 ** We have to use our own definitions instead of the mandatory (!) unwind.h,
 402 ** since various OS, distros and compilers mess up the header installation.
 403 */
 404
 405 typedef struct _Unwind_Context _Unwind_Context;
 406
 407 #define _URC_OK                 0
 408 #define _URC_FATAL_PHASE2_ERROR 2
 409 #define _URC_FATAL_PHASE1_ERROR 3
 410 #define _URC_HANDLER_FOUND      6
 411 #define _URC_INSTALL_CONTEXT    7
 412 #define _URC_CONTINUE_UNWIND    8
 413 #define _URC_FAILURE            9
 414
 415 #define LJ_UEXCLASS             0x4c55414a49543200ULL   /* LUAJIT2\0 */
 416 #define LJ_UEXCLASS_MAKE(c)     (LJ_UEXCLASS | (uint64_t)(c))
 417 #define LJ_UEXCLASS_CHECK(cl)   (((cl) ^ LJ_UEXCLASS) <= 0xff)
 418 #define LJ_UEXCLASS_ERRCODE(cl) ((int)((cl) & 0xff))
 419
 420 #if !LJ_TARGET_ARM
 421
 422 typedef struct _Unwind_Exception
 423 {
 424   uint64_t exclass;
 425   void (*excleanup)(int, struct _Unwind_Exception *);
 426   uintptr_t p1, p2;
 427 } __attribute__((__aligned__)) _Unwind_Exception;
 428 #define UNWIND_EXCEPTION_TYPE   _Unwind_Exception
 429
 430 extern uintptr_t _Unwind_GetCFA(_Unwind_Context *);
 431 extern void _Unwind_SetGR(_Unwind_Context *, int, uintptr_t);
 432 extern uintptr_t _Unwind_GetIP(_Unwind_Context *);
 433 extern void _Unwind_SetIP(_Unwind_Context *, uintptr_t);
 434 extern void _Unwind_DeleteException(_Unwind_Exception *);
 435 extern int _Unwind_RaiseException(_Unwind_Exception *);
 436
 437 #define _UA_SEARCH_PHASE        1
 438 #define _UA_CLEANUP_PHASE       2
 439 #define _UA_HANDLER_FRAME       4
 440 #define _UA_FORCE_UNWIND        8
 441
 442 /* DWARF2 personality handler referenced from interpreter .eh_frame. */
 443 LJ_FUNCA int lj_err_unwind_dwarf(int version, int actions,
 444   uint64_t uexclass, _Unwind_Exception *uex, _Unwind_Context *ctx)
 445 {
 446   void *cf;
 447   lua_State *L;
 448   if (version != 1)
 449     return _URC_FATAL_PHASE1_ERROR;
 450   cf = (void *)_Unwind_GetCFA(ctx);
 451   L = cframe_L(cf);
 452   if ((actions & _UA_SEARCH_PHASE)) {
 453 #if LJ_UNWIND_EXT
 454     if (err_unwind(L, cf, 0) == NULL)
 455       return _URC_CONTINUE_UNWIND;
 456 #endif
 457     if (!LJ_UEXCLASS_CHECK(uexclass)) {
 458       setstrV(L, L->top++, lj_err_str(L, LJ_ERR_ERRCPP));
 459     }
 460     return _URC_HANDLER_FOUND;
 461   }
 462   if ((actions & _UA_CLEANUP_PHASE)) {
 463     int errcode;
 464     if (LJ_UEXCLASS_CHECK(uexclass)) {
 465       errcode = LJ_UEXCLASS_ERRCODE(uexclass);
 466     } else {
 467       if ((actions & _UA_HANDLER_FRAME))
 468         _Unwind_DeleteException(uex);
 469       errcode = LUA_ERRRUN;
 470     }
 471 #if LJ_UNWIND_EXT
 472     cf = err_unwind(L, cf, errcode);
 473     if ((actions & _UA_FORCE_UNWIND)) {
 474       return _URC_CONTINUE_UNWIND;
 475     } else if (cf) {
 476       ASMFunction ip;
 477       _Unwind_SetGR(ctx, LJ_TARGET_EHRETREG, errcode);
 478       ip = cframe_unwind_ff(cf) ? lj_vm_unwind_ff_eh : lj_vm_unwind_c_eh;
 479       _Unwind_SetIP(ctx, (uintptr_t)lj_ptr_strip(ip));
 480       return _URC_INSTALL_CONTEXT;
 481     }
 482 #if LJ_TARGET_X86ORX64
 483     else if ((actions & _UA_HANDLER_FRAME)) {
 484       /* Workaround for ancient libgcc bug. Still present in RHEL 5.5. :-/
 485       ** Real fix: http://gcc.gnu.org/viewcvs/trunk/gcc/unwind-dw2.c?r1=121165&r2=124837&pathrev=153877&diff_format=h
 486       */
 487       _Unwind_SetGR(ctx, LJ_TARGET_EHRETREG, errcode);
 488       _Unwind_SetIP(ctx, (uintptr_t)lj_vm_unwind_rethrow);
 489       return _URC_INSTALL_CONTEXT;
 490     }
 491 #endif
 492 #else
 493     /* This is not the proper way to escape from the unwinder. We get away with
 494     ** it on non-x64 because the interpreter restores all callee-saved regs.
 495     */
 496     lj_err_throw(L, errcode);
 497 #if LJ_TARGET_X64
 498 #error "Broken build system -- only use the provided Makefiles!"
 499 #endif
 500 #endif
 501   }
 502   return _URC_CONTINUE_UNWIND;
 503 }
 504
 505 #if LJ_UNWIND_EXT && defined(LUA_USE_ASSERT)
 506 struct dwarf_eh_bases { void *tbase, *dbase, *func; };
 507 extern const void *_Unwind_Find_FDE(void *pc, struct dwarf_eh_bases *bases);
 508
 509 /* Verify that external error handling actually has a chance to work. */
 510 void lj_err_verify(void)
 511 {
 512 #if !LJ_TARGET_OSX
 513   /* Check disabled on MacOS due to brilliant software engineering at Apple. */
 514   struct dwarf_eh_bases ehb;
 515   lj_assertX(_Unwind_Find_FDE((void *)lj_err_throw, &ehb), "broken build: external frame unwinding enabled, but missing -funwind-tables");
 516 #endif
 517   /* Check disabled, because of broken Fedora/ARM64. See #722.
 518   lj_assertX(_Unwind_Find_FDE((void *)_Unwind_RaiseException, &ehb), "broken build: external frame unwinding enabled, but system libraries have no unwind tables");
 519   */
 520 }
 521 #endif
 522
 523 #if LJ_UNWIND_JIT
 524 /* DWARF2 personality handler for JIT-compiled code. */
 525 static int err_unwind_jit(int version, int actions,
 526   uint64_t uexclass, _Unwind_Exception *uex, _Unwind_Context *ctx)
 527 {
 528   /* NYI: FFI C++ exception interoperability. */
 529   if (version != 1 || !LJ_UEXCLASS_CHECK(uexclass))
 530     return _URC_FATAL_PHASE1_ERROR;
 531   if ((actions & _UA_SEARCH_PHASE)) {
 532     return _URC_HANDLER_FOUND;
 533   }
 534   if ((actions & _UA_CLEANUP_PHASE)) {
 535     global_State *g = *(global_State **)(uex+1);
 536     ExitNo exitno;
 537     uintptr_t addr = _Unwind_GetIP(ctx);  /* Return address _after_ call. */
 538     uintptr_t stub = lj_trace_unwind(G2J(g), addr - sizeof(MCode), &exitno);
 539     lj_assertG(tvref(g->jit_base), "unexpected throw across mcode frame");
 540     if (stub) {  /* Jump to side exit to unwind the trace. */
 541       G2J(g)->exitcode = LJ_UEXCLASS_ERRCODE(uexclass);
 542 #ifdef LJ_TARGET_MIPS
 543       _Unwind_SetGR(ctx, 4, stub);
 544       _Unwind_SetGR(ctx, 5, exitno);
 545       _Unwind_SetIP(ctx, (uintptr_t)(void *)lj_vm_unwind_stub);
 546 #else
 547       _Unwind_SetIP(ctx, stub);
 548 #endif
 549       return _URC_INSTALL_CONTEXT;
 550     }
 551     return _URC_FATAL_PHASE2_ERROR;
 552   }
 553   return _URC_FATAL_PHASE1_ERROR;
 554 }
 555
 556 /* DWARF2 template frame info for JIT-compiled code.
 557 **
 558 ** After copying the template to the start of the mcode segment,
 559 ** the frame handler function and the code size is patched.
 560 ** The frame handler always installs a new context to jump to the exit,
 561 ** so don't bother to add any unwind opcodes.
 562 */
 563 static const uint8_t err_frame_jit_template[] = {
 564 #if LJ_BE
 565   0,0,0,
 566 #endif
 567   LJ_64 ? 0x1c : 0x14,  /* CIE length. */
 568 #if LJ_LE
 569   0,0,0,
 570 #endif
 571   0,0,0,0, 1, 'z','P','R',0,  /* CIE mark, CIE version, augmentation. */
 572   1, LJ_64 ? 0x78 : 0x7c, LJ_TARGET_EHRAREG,  /* Code/data align, RA. */
 573 #if LJ_64
 574   10, 0, 0,0,0,0,0,0,0,0, 0x1b,  /* Aug. data ABS handler, PCREL|SDATA4 code. */
 575   0,0,0,0,0,  /* Alignment. */
 576 #else
 577   6, 0, 0,0,0,0, 0x1b,  /* Aug. data ABS handler, PCREL|SDATA4 code. */
 578   0,  /* Alignment. */
 579 #endif
 580 #if LJ_BE
 581   0,0,0,
 582 #endif
 583   LJ_64 ? 0x14 : 0x10,  /* FDE length. */
 584   0,0,0,
 585   LJ_64 ? 0x24 : 0x1c,  /* CIE offset. */
 586   0,0,0,
 587   LJ_64 ? 0x14 : 0x10,  /* Code offset. After Final FDE. */
 588 #if LJ_LE
 589   0,0,0,
 590 #endif
 591   0,0,0,0, 0, 0,0,0, /* Code size, augmentation length, alignment. */
 592 #if LJ_64
 593   0,0,0,0,  /* Alignment. */
 594 #endif
 595   0,0,0,0  /* Final FDE. */
 596 };
 597
 598 #define ERR_FRAME_JIT_OFS_HANDLER       0x12
 599 #define ERR_FRAME_JIT_OFS_FDE           (LJ_64 ? 0x20 : 0x18)
 600 #define ERR_FRAME_JIT_OFS_CODE_SIZE     (LJ_64 ? 0x2c : 0x24)
 601 #if LJ_TARGET_OSX
 602 #define ERR_FRAME_JIT_OFS_REGISTER      ERR_FRAME_JIT_OFS_FDE
 603 #else
 604 #define ERR_FRAME_JIT_OFS_REGISTER      0
 605 #endif
 606
 607 extern void __register_frame(const void *);
 608 extern void __deregister_frame(const void *);
 609
 610 uint8_t *lj_err_register_mcode(void *base, size_t sz, uint8_t *info)
 611 {
 612   ASMFunction handler = (ASMFunction)err_unwind_jit;
 613   memcpy(info, err_frame_jit_template, sizeof(err_frame_jit_template));
 614 #if LJ_ABI_PAUTH
 615 #if LJ_TARGET_ARM64
 616   handler = ptrauth_auth_and_resign(handler,
 617     ptrauth_key_function_pointer, 0,
 618     ptrauth_key_process_independent_code, info + ERR_FRAME_JIT_OFS_HANDLER);
 619 #else
 620 #error "missing pointer authentication support for this architecture"
 621 #endif
 622 #endif
 623   memcpy(info + ERR_FRAME_JIT_OFS_HANDLER, &handler, sizeof(handler));
 624   *(uint32_t *)(info + ERR_FRAME_JIT_OFS_CODE_SIZE) =
 625     (uint32_t)(sz - sizeof(err_frame_jit_template) - (info - (uint8_t *)base));
 626   __register_frame(info + ERR_FRAME_JIT_OFS_REGISTER);
 627 #ifdef LUA_USE_ASSERT
 628   {
 629     struct dwarf_eh_bases ehb;
 630     lj_assertX(_Unwind_Find_FDE(info + sizeof(err_frame_jit_template)+1, &ehb),
 631                "bad JIT unwind table registration");
 632   }
 633 #endif
 634   return info + sizeof(err_frame_jit_template);
 635 }
 636
 637 void lj_err_deregister_mcode(void *base, size_t sz, uint8_t *info)
 638 {
 639   UNUSED(base); UNUSED(sz);
 640   __deregister_frame(info + ERR_FRAME_JIT_OFS_REGISTER);
 641 }
 642 #endif
 643
 644 #else /* LJ_TARGET_ARM */
 645
 646 #define _US_VIRTUAL_UNWIND_FRAME        0
 647 #define _US_UNWIND_FRAME_STARTING       1
 648 #define _US_ACTION_MASK                 3
 649 #define _US_FORCE_UNWIND                8
 650
 651 typedef struct _Unwind_Control_Block _Unwind_Control_Block;
 652 #define UNWIND_EXCEPTION_TYPE   _Unwind_Control_Block
 653
 654 struct _Unwind_Control_Block {
 655   uint64_t exclass;
 656   uint32_t misc[20];
 657 };
 658
 659 extern int _Unwind_RaiseException(_Unwind_Control_Block *);
 660 extern int __gnu_unwind_frame(_Unwind_Control_Block *, _Unwind_Context *);
 661 extern int _Unwind_VRS_Set(_Unwind_Context *, int, uint32_t, int, void *);
 662 extern int _Unwind_VRS_Get(_Unwind_Context *, int, uint32_t, int, void *);
 663
 664 static inline uint32_t _Unwind_GetGR(_Unwind_Context *ctx, int r)
 665 {
 666   uint32_t v;
 667   _Unwind_VRS_Get(ctx, 0, r, 0, &v);
 668   return v;
 669 }
 670
 671 static inline void _Unwind_SetGR(_Unwind_Context *ctx, int r, uint32_t v)
 672 {
 673   _Unwind_VRS_Set(ctx, 0, r, 0, &v);
 674 }
 675
 676 extern void lj_vm_unwind_ext(void);
 677
 678 /* ARM unwinder personality handler referenced from interpreter .ARM.extab. */
 679 LJ_FUNCA int lj_err_unwind_arm(int state, _Unwind_Control_Block *ucb,
 680                                _Unwind_Context *ctx)
 681 {
 682   void *cf = (void *)_Unwind_GetGR(ctx, 13);
 683   lua_State *L = cframe_L(cf);
 684   int errcode;
 685
 686   switch ((state & _US_ACTION_MASK)) {
 687   case _US_VIRTUAL_UNWIND_FRAME:
 688     if ((state & _US_FORCE_UNWIND)) break;
 689     return _URC_HANDLER_FOUND;
 690   case _US_UNWIND_FRAME_STARTING:
 691     if (LJ_UEXCLASS_CHECK(ucb->exclass)) {
 692       errcode = LJ_UEXCLASS_ERRCODE(ucb->exclass);
 693     } else {
 694       errcode = LUA_ERRRUN;
 695       setstrV(L, L->top++, lj_err_str(L, LJ_ERR_ERRCPP));
 696     }
 697     cf = err_unwind(L, cf, errcode);
 698     if ((state & _US_FORCE_UNWIND) || cf == NULL) break;
 699     _Unwind_SetGR(ctx, 15, (uint32_t)lj_vm_unwind_ext);
 700     _Unwind_SetGR(ctx, 0, (uint32_t)ucb);
 701     _Unwind_SetGR(ctx, 1, (uint32_t)errcode);
 702     _Unwind_SetGR(ctx, 2, cframe_unwind_ff(cf) ?
 703                             (uint32_t)lj_vm_unwind_ff_eh :
 704                             (uint32_t)lj_vm_unwind_c_eh);
 705     return _URC_INSTALL_CONTEXT;
 706   default:
 707     return _URC_FAILURE;
 708   }
 709   if (__gnu_unwind_frame(ucb, ctx) != _URC_OK)
 710     return _URC_FAILURE;
 711 #ifdef LUA_USE_ASSERT
 712   /* We should never get here unless this is a forced unwind aka backtrace. */
 713   if (_Unwind_GetGR(ctx, 0) == 0xff33aa77) {
 714     _Unwind_SetGR(ctx, 0, 0xff33aa88);
 715   }
 716 #endif
 717   return _URC_CONTINUE_UNWIND;
 718 }
 719
 720 #if LJ_UNWIND_EXT && defined(LUA_USE_ASSERT)
 721 typedef int (*_Unwind_Trace_Fn)(_Unwind_Context *, void *);
 722 extern int _Unwind_Backtrace(_Unwind_Trace_Fn, void *);
 723
 724 static int err_verify_bt(_Unwind_Context *ctx, int *got)
 725 {
 726   if (_Unwind_GetGR(ctx, 0) == 0xff33aa88) { *got = 2; }
 727   else if (*got == 0) { *got = 1; _Unwind_SetGR(ctx, 0, 0xff33aa77); }
 728   return _URC_OK;
 729 }
 730
 731 /* Verify that external error handling actually has a chance to work. */
 732 void lj_err_verify(void)
 733 {
 734   int got = 0;
 735   _Unwind_Backtrace((_Unwind_Trace_Fn)err_verify_bt, &got);
 736   lj_assertX(got == 2, "broken build: external frame unwinding enabled, but missing -funwind-tables");
 737 }
 738 #endif
 739
 740 /*
 741 ** Note: LJ_UNWIND_JIT is not implemented for 32 bit ARM.
 742 **
 743 ** The quirky ARM unwind API doesn't have __register_frame().
 744 ** A potential workaround might involve _Unwind_Backtrace.
 745 ** But most 32 bit ARM targets don't qualify for LJ_UNWIND_EXT, anyway,
 746 ** since they are built without unwind tables by default.
 747 */
 748
 749 #endif /* LJ_TARGET_ARM */
 750
 751
 752 #if LJ_UNWIND_EXT
 753 static __thread struct {
 754   UNWIND_EXCEPTION_TYPE ex;
 755   global_State *g;
 756 } static_uex;
 757
 758 /* Raise external exception. */
 759 static void err_raise_ext(global_State *g, int errcode)
 760 {
 761   memset(&static_uex, 0, sizeof(static_uex));
 762   static_uex.ex.exclass = LJ_UEXCLASS_MAKE(errcode);
 763   static_uex.g = g;
 764   _Unwind_RaiseException(&static_uex.ex);
 765 }
 766
 767 #endif
 768
 769 #endif
 770
 771 /* -- Error handling ------------------------------------------------------ */
 772
 773 /* Throw error. Find catch frame, unwind stack and continue. */
 774 LJ_NOINLINE void LJ_FASTCALL lj_err_throw(lua_State *L, int errcode)
 775 {
 776   global_State *g = G(L);
 777   lj_trace_abort(g);
 778   L->status = LUA_OK;
 779 #if LJ_UNWIND_EXT
 780   err_raise_ext(g, errcode);
 781   /*
 782   ** A return from this function signals a corrupt C stack that cannot be
 783   ** unwound. We have no choice but to call the panic function and exit.
 784   **
 785   ** Usually this is caused by a C function without unwind information.
 786   ** This may happen if you've manually enabled LUAJIT_UNWIND_EXTERNAL
 787   ** and forgot to recompile *every* non-C++ file with -funwind-tables.
 788   */
 789   if (G(L)->panic)
 790     G(L)->panic(L);
 791 #else
 792 #if LJ_HASJIT
 793   setmref(g->jit_base, NULL);
 794 #endif
 795   {
 796     void *cf = err_unwind(L, NULL, errcode);
 797     if (cframe_unwind_ff(cf))
 798       lj_vm_unwind_ff(cframe_raw(cf));
 799     else
 800       lj_vm_unwind_c(cframe_raw(cf), errcode);
 801   }
 802 #endif
 803   exit(EXIT_FAILURE);
 804 }
 805
 806 /* Return string object for error message. */
 807 LJ_NOINLINE GCstr *lj_err_str(lua_State *L, ErrMsg em)
 808 {
 809   return lj_str_newz(L, err2msg(em));
 810 }
 811
 812 /* Out-of-memory error. */
 813 LJ_NOINLINE void lj_err_mem(lua_State *L)
 814 {
 815   if (L->status == LUA_ERRERR+1)  /* Don't touch the stack during lua_open. */
 816     lj_vm_unwind_c(L->cframe, LUA_ERRMEM);
 817   if (LJ_HASJIT) {
 818     TValue *base = tvref(G(L)->jit_base);
 819     if (base) L->base = base;
 820   }
 821   if (curr_funcisL(L)) L->top = curr_topL(L);
 822   setstrV(L, L->top++, lj_err_str(L, LJ_ERR_ERRMEM));
 823   lj_err_throw(L, LUA_ERRMEM);
 824 }
 825
 826 /* Find error function for runtime errors. Requires an extra stack traversal. */
 827 static ptrdiff_t finderrfunc(lua_State *L)
 828 {
 829   cTValue *frame = L->base-1, *bot = tvref(L->stack)+LJ_FR2;
 830   void *cf = L->cframe;
 831   while (frame > bot && cf) {
 832     while (cframe_nres(cframe_raw(cf)) < 0) {  /* cframe without frame? */
 833       if (frame >= restorestack(L, -cframe_nres(cf)))
 834         break;
 835       if (cframe_errfunc(cf) >= 0)  /* Error handler not inherited (-1)? */
 836         return cframe_errfunc(cf);
 837       cf = cframe_prev(cf);  /* Else unwind cframe and continue searching. */
 838       if (cf == NULL)
 839         return 0;
 840     }
 841     switch (frame_typep(frame)) {
 842     case FRAME_LUA:
 843     case FRAME_LUAP:
 844       frame = frame_prevl(frame);
 845       break;
 846     case FRAME_C:
 847       cf = cframe_prev(cf);
 848       /* fallthrough */
 849     case FRAME_VARG:
 850       frame = frame_prevd(frame);
 851       break;
 852     case FRAME_CONT:
 853       if (frame_iscont_fficb(frame))
 854         cf = cframe_prev(cf);
 855       frame = frame_prevd(frame);
 856       break;
 857     case FRAME_CP:
 858       if (cframe_canyield(cf)) return 0;
 859       if (cframe_errfunc(cf) >= 0)
 860         return cframe_errfunc(cf);
 861       cf = cframe_prev(cf);
 862       frame = frame_prevd(frame);
 863       break;
 864     case FRAME_PCALL:
 865     case FRAME_PCALLH:
 866       if (frame_func(frame_prevd(frame))->c.ffid == FF_xpcall)
 867         return savestack(L, frame_prevd(frame)+1);  /* xpcall's errorfunc. */
 868       return 0;
 869     default:
 870       lj_assertL(0, "bad frame type");
 871       return 0;
 872     }
 873   }
 874   return 0;
 875 }
 876
 877 /* Runtime error. */
 878 LJ_NOINLINE void LJ_FASTCALL lj_err_run(lua_State *L)
 879 {
 880   ptrdiff_t ef = (LJ_HASJIT && tvref(G(L)->jit_base)) ? 0 : finderrfunc(L);
 881   if (ef) {
 882     TValue *errfunc = restorestack(L, ef);
 883     TValue *top = L->top;
 884     lj_trace_abort(G(L));
 885     if (!tvisfunc(errfunc) || L->status == LUA_ERRERR) {
 886       setstrV(L, top-1, lj_err_str(L, LJ_ERR_ERRERR));
 887       lj_err_throw(L, LUA_ERRERR);
 888     }
 889     L->status = LUA_ERRERR;
 890     copyTV(L, top+LJ_FR2, top-1);
 891     copyTV(L, top-1, errfunc);
 892     if (LJ_FR2) setnilV(top++);
 893     L->top = top+1;
 894     lj_vm_call(L, top, 1+1);  /* Stack: |errfunc|msg| -> |msg| */
 895   }
 896   lj_err_throw(L, LUA_ERRRUN);
 897 }
 898
 899 #if LJ_HASJIT
 900 LJ_NOINLINE void LJ_FASTCALL lj_err_trace(lua_State *L, int errcode)
 901 {
 902   if (errcode == LUA_ERRRUN)
 903     lj_err_run(L);
 904   else
 905     lj_err_throw(L, errcode);
 906 }
 907 #endif
 908
 909 /* Formatted runtime error message. */
 910 LJ_NORET LJ_NOINLINE static void err_msgv(lua_State *L, ErrMsg em, ...)
 911 {
 912   const char *msg;
 913   va_list argp;
 914   va_start(argp, em);
 915   if (LJ_HASJIT) {
 916     TValue *base = tvref(G(L)->jit_base);
 917     if (base) L->base = base;
 918   }
 919   if (curr_funcisL(L)) L->top = curr_topL(L);
 920   msg = lj_strfmt_pushvf(L, err2msg(em), argp);
 921   va_end(argp);
 922   lj_debug_addloc(L, msg, L->base-1, NULL);
 923   lj_err_run(L);
 924 }
 925
 926 /* Non-vararg variant for better calling conventions. */
 927 LJ_NOINLINE void lj_err_msg(lua_State *L, ErrMsg em)
 928 {
 929   err_msgv(L, em);
 930 }
 931
 932 /* Lexer error. */
 933 LJ_NOINLINE void lj_err_lex(lua_State *L, GCstr *src, const char *tok,
 934                             BCLine line, ErrMsg em, va_list argp)
 935 {
 936   char buff[LUA_IDSIZE];
 937   const char *msg;
 938   lj_debug_shortname(buff, src, line);
 939   msg = lj_strfmt_pushvf(L, err2msg(em), argp);
 940   msg = lj_strfmt_pushf(L, "%s:%d: %s", buff, line, msg);
 941   if (tok)
 942     lj_strfmt_pushf(L, err2msg(LJ_ERR_XNEAR), msg, tok);
 943   lj_err_throw(L, LUA_ERRSYNTAX);
 944 }
 945
 946 /* Typecheck error for operands. */
 947 LJ_NOINLINE void lj_err_optype(lua_State *L, cTValue *o, ErrMsg opm)
 948 {
 949   const char *tname = lj_typename(o);
 950   const char *opname = err2msg(opm);
 951   if (curr_funcisL(L)) {
 952     GCproto *pt = curr_proto(L);
 953     const BCIns *pc = cframe_Lpc(L) - 1;
 954     const char *oname = NULL;
 955     const char *kind = lj_debug_slotname(pt, pc, (BCReg)(o-L->base), &oname);
 956     if (kind)
 957       err_msgv(L, LJ_ERR_BADOPRT, opname, kind, oname, tname);
 958   }
 959   err_msgv(L, LJ_ERR_BADOPRV, opname, tname);
 960 }
 961
 962 /* Typecheck error for ordered comparisons. */
 963 LJ_NOINLINE void lj_err_comp(lua_State *L, cTValue *o1, cTValue *o2)
 964 {
 965   const char *t1 = lj_typename(o1);
 966   const char *t2 = lj_typename(o2);
 967   err_msgv(L, t1 == t2 ? LJ_ERR_BADCMPV : LJ_ERR_BADCMPT, t1, t2);
 968   /* This assumes the two "boolean" entries are commoned by the C compiler. */
 969 }
 970
 971 /* Typecheck error for __call. */
 972 LJ_NOINLINE void lj_err_optype_call(lua_State *L, TValue *o)
 973 {
 974   /* Gross hack if lua_[p]call or pcall/xpcall fail for a non-callable object:
 975   ** L->base still points to the caller. So add a dummy frame with L instead
 976   ** of a function. See lua_getstack().
 977   */
 978   const BCIns *pc = cframe_Lpc(L);
 979   if (((ptrdiff_t)pc & FRAME_TYPE) != FRAME_LUA) {
 980     const char *tname = lj_typename(o);
 981     setframe_gc(o, obj2gco(L), LJ_TTHREAD);
 982     if (LJ_FR2) o++;
 983     setframe_pc(o, pc);
 984     L->top = L->base = o+1;
 985     err_msgv(L, LJ_ERR_BADCALL, tname);
 986   }
 987   lj_err_optype(L, o, LJ_ERR_OPCALL);
 988 }
 989
 990 /* Error in context of caller. */
 991 LJ_NOINLINE void lj_err_callermsg(lua_State *L, const char *msg)
 992 {
 993   TValue *frame = NULL, *pframe = NULL;
 994   if (!(LJ_HASJIT && tvref(G(L)->jit_base))) {
 995     frame = L->base-1;
 996     if (frame_islua(frame)) {
 997       pframe = frame_prevl(frame);
 998     } else if (frame_iscont(frame)) {
 999       if (frame_iscont_fficb(frame)) {
1000         pframe = frame;
1001         frame = NULL;
1002       } else {
1003         pframe = frame_prevd(frame);
1004 #if LJ_HASFFI
1005         /* Remove frame for FFI metamethods. */
1006         if (frame_func(frame)->c.ffid >= FF_ffi_meta___index &&
1007             frame_func(frame)->c.ffid <= FF_ffi_meta___tostring) {
1008           L->base = pframe+1;
1009           L->top = frame;
1010           setcframe_pc(cframe_raw(L->cframe), frame_contpc(frame));
1011         }
1012 #endif
1013       }
1014     }
1015   }
1016   lj_debug_addloc(L, msg, pframe, frame);
1017   lj_err_run(L);
1018 }
1019
1020 /* Formatted error in context of caller. */
1021 LJ_NOINLINE void lj_err_callerv(lua_State *L, ErrMsg em, ...)
1022 {
1023   const char *msg;
1024   va_list argp;
1025   va_start(argp, em);
1026   msg = lj_strfmt_pushvf(L, err2msg(em), argp);
1027   va_end(argp);
1028   lj_err_callermsg(L, msg);
1029 }
1030
1031 /* Error in context of caller. */
1032 LJ_NOINLINE void lj_err_caller(lua_State *L, ErrMsg em)
1033 {
1034   lj_err_callermsg(L, err2msg(em));
1035 }
1036
1037 /* Argument error message. */
1038 LJ_NORET LJ_NOINLINE static void err_argmsg(lua_State *L, int narg,
1039                                             const char *msg)
1040 {
1041   const char *fname = "?";
1042   const char *ftype = lj_debug_funcname(L, L->base - 1, &fname);
1043   if (narg < 0 && narg > LUA_REGISTRYINDEX)
1044     narg = (int)(L->top - L->base) + narg + 1;
1045   if (ftype && ftype[3] == 'h' && --narg == 0)  /* Check for "method". */
1046     msg = lj_strfmt_pushf(L, err2msg(LJ_ERR_BADSELF), fname, msg);
1047   else
1048     msg = lj_strfmt_pushf(L, err2msg(LJ_ERR_BADARG), narg, fname, msg);
1049   lj_err_callermsg(L, msg);
1050 }
1051
1052 /* Formatted argument error. */
1053 LJ_NOINLINE void lj_err_argv(lua_State *L, int narg, ErrMsg em, ...)
1054 {
1055   const char *msg;
1056   va_list argp;
1057   va_start(argp, em);
1058   msg = lj_strfmt_pushvf(L, err2msg(em), argp);
1059   va_end(argp);
1060   err_argmsg(L, narg, msg);
1061 }
1062
1063 /* Argument error. */
1064 LJ_NOINLINE void lj_err_arg(lua_State *L, int narg, ErrMsg em)
1065 {
1066   err_argmsg(L, narg, err2msg(em));
1067 }
1068
1069 /* Typecheck error for arguments. */
1070 LJ_NOINLINE void lj_err_argtype(lua_State *L, int narg, const char *xname)
1071 {
1072   const char *tname, *msg;
1073   if (narg <= LUA_REGISTRYINDEX) {
1074     if (narg >= LUA_GLOBALSINDEX) {
1075       tname = lj_obj_itypename[~LJ_TTAB];
1076     } else {
1077       GCfunc *fn = curr_func(L);
1078       int idx = LUA_GLOBALSINDEX - narg;
1079       if (idx <= fn->c.nupvalues)
1080         tname = lj_typename(&fn->c.upvalue[idx-1]);
1081       else
1082         tname = lj_obj_typename[0];
1083     }
1084   } else {
1085     TValue *o = narg < 0 ? L->top + narg : L->base + narg-1;
1086     tname = o < L->top ? lj_typename(o) : lj_obj_typename[0];
1087   }
1088   msg = lj_strfmt_pushf(L, err2msg(LJ_ERR_BADTYPE), xname, tname);
1089   err_argmsg(L, narg, msg);
1090 }
1091
1092 /* Typecheck error for arguments. */
1093 LJ_NOINLINE void lj_err_argt(lua_State *L, int narg, int tt)
1094 {
1095   lj_err_argtype(L, narg, lj_obj_typename[tt+1]);
1096 }
1097
1098 /* -- Public error handling API ------------------------------------------- */
1099
1100 LUA_API lua_CFunction lua_atpanic(lua_State *L, lua_CFunction panicf)
1101 {
1102   lua_CFunction old = G(L)->panic;
1103   G(L)->panic = panicf;
1104   return old;
1105 }
1106
1107 /* Forwarders for the public API (C calling convention and no LJ_NORET). */
1108 LUA_API int lua_error(lua_State *L)
1109 {
1110   lj_err_run(L);
1111   return 0;  /* unreachable */
1112 }
1113
1114 LUALIB_API int luaL_argerror(lua_State *L, int narg, const char *msg)
1115 {
1116   err_argmsg(L, narg, msg);
1117   return 0;  /* unreachable */
1118 }
1119
1120 LUALIB_API int luaL_typerror(lua_State *L, int narg, const char *xname)
1121 {
1122   lj_err_argtype(L, narg, xname);
1123   return 0;  /* unreachable */
1124 }
1125
1126 LUALIB_API void luaL_where(lua_State *L, int level)
1127 {
1128   int size;
1129   cTValue *frame = lj_debug_frame(L, level, &size);
1130   lj_debug_addloc(L, "", frame, size ? frame+size : NULL);
1131 }
1132
1133 LUALIB_API int luaL_error(lua_State *L, const char *fmt, ...)
1134 {
1135   const char *msg;
1136   va_list argp;
1137   va_start(argp, fmt);
1138   msg = lj_strfmt_pushvf(L, fmt, argp);
1139   va_end(argp);
1140   lj_err_callermsg(L, msg);
1141   return 0;  /* unreachable */
1142 }
1143