One Level Up Top Level

src/lib_jit.c - luajit-2.0-src

Global variables defined

Functions defined

Macros defined

Source code

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

  6. ‌#define lib_jit_c
  7. ‌#define LUA_LIB

  9. #include "lua.h"
  10. #include "lauxlib.h"
  11. #include "lualib.h"

  13. #include "lj_obj.h"
  14. #include "lj_gc.h"
  15. #include "lj_err.h"
  16. #include "lj_debug.h"
  17. #include "lj_str.h"
  18. #include "lj_tab.h"
  19. #include "lj_state.h"
  20. #include "lj_bc.h"
  21. #if LJ_HASFFI
  22. #include "lj_ctype.h"
  23. #endif
  24. #if LJ_HASJIT
  25. #include "lj_ir.h"
  26. #include "lj_jit.h"
  27. #include "lj_ircall.h"
  28. #include "lj_iropt.h"
  29. #include "lj_target.h"
  30. #endif
  31. #include "lj_trace.h"
  32. #include "lj_dispatch.h"
  33. #include "lj_vm.h"
  34. #include "lj_vmevent.h"
  35. #include "lj_lib.h"

  37. #include "luajit.h"

  39. /* -- jit.* functions ----------------------------------------------------- */

  41. ‌#define LJLIB_MODULE_jit

  43. ‌static int setjitmode(lua_State *L, int mode)
  44. {
  45.   int idx = 0;
  46.   if (L->base == L->top || tvisnil(L->base)) {  /* jit.on/off/flush([nil]) */
  47.     mode |= LUAJIT_MODE_ENGINE;
  48.   } else {
  49.     /* jit.on/off/flush(func|proto, nil|true|false) */
  50.     if (tvisfunc(L->base) || tvisproto(L->base))
  51.       idx = 1;
  52.     else if (!tvistrue(L->base))  /* jit.on/off/flush(true, nil|true|false) */
  53.       goto err;
  54.     if (L->base+1 < L->top && tvisbool(L->base+1))
  55.       mode |= boolV(L->base+1) ? LUAJIT_MODE_ALLFUNC : LUAJIT_MODE_ALLSUBFUNC;
  56.     else
  57.       mode |= LUAJIT_MODE_FUNC;
  58.   }
  59.   if (luaJIT_setmode(L, idx, mode) != 1) {
  60.     if ((mode & LUAJIT_MODE_MASK) == LUAJIT_MODE_ENGINE)
  61.       lj_err_caller(L, LJ_ERR_NOJIT);
  62.   err:
  63.     lj_err_argt(L, 1, LUA_TFUNCTION);
  64.   }
  65.   return 0;
  66. }

  68. ‌LJLIB_CF(jit_on)
  69. {
  70.   return setjitmode(L, LUAJIT_MODE_ON);
  71. }

  73. ‌LJLIB_CF(jit_off)
  74. {
  75.   return setjitmode(L, LUAJIT_MODE_OFF);
  76. }

  78. ‌LJLIB_CF(jit_flush)
  79. {
  80. #if LJ_HASJIT
  81.   if (L->base < L->top && tvisnumber(L->base)) {
  82.     int traceno = lj_lib_checkint(L, 1);
  83.     luaJIT_setmode(L, traceno, LUAJIT_MODE_FLUSH|LUAJIT_MODE_TRACE);
  84.     return 0;
  85.   }
  86. #endif
  87.   return setjitmode(L, LUAJIT_MODE_FLUSH);
  88. }

  90. #if LJ_HASJIT
  91. /* Push a string for every flag bit that is set. */
  92. ‌static void flagbits_to_strings(lua_State *L, uint32_t flags, uint32_t base,
  93.                                 const char *str)
  94. {
  95.   for (; *str; base <<= 1, str += 1+*str)
  96.     if (flags & base)
  97.       setstrV(L, L->top++, lj_str_new(L, str+1, *(uint8_t *)str));
  98. }
  99. #endif

  101. ‌LJLIB_CF(jit_status)
  102. {
  103. #if LJ_HASJIT
  104.   jit_State *J = L2J(L);
  105.   L->top = L->base;
  106.   setboolV(L->top++, (J->flags & JIT_F_ON) ? 1 : 0);
  107.   flagbits_to_strings(L, J->flags, JIT_F_CPU_FIRST, JIT_F_CPUSTRING);
  108.   flagbits_to_strings(L, J->flags, JIT_F_OPT_FIRST, JIT_F_OPTSTRING);
  109.   return (int)(L->top - L->base);
  110. #else
  111.   setboolV(L->top++, 0);
  112.   return 1;
  113. #endif
  114. }

  116. ‌LJLIB_CF(jit_attach)
  117. {
  118. #ifdef LUAJIT_DISABLE_VMEVENT
  119.   luaL_error(L, "vmevent API disabled");
  120. #else
  121.   GCfunc *fn = lj_lib_checkfunc(L, 1);
  122.   GCstr *s = lj_lib_optstr(L, 2);
  123.   luaL_findtable(L, LUA_REGISTRYINDEX, LJ_VMEVENTS_REGKEY, LJ_VMEVENTS_HSIZE);
  124.   if (s) {  /* Attach to given event. */
  125.     const uint8_t *p = (const uint8_t *)strdata(s);
  126.     uint32_t h = s->len;
  127.     while (*p) h = h ^ (lj_rol(h, 6) + *p++);
  128.     lua_pushvalue(L, 1);
  129.     lua_rawseti(L, -2, VMEVENT_HASHIDX(h));
  130.     G(L)->vmevmask = VMEVENT_NOCACHE;  /* Invalidate cache. */
  131.   } else {  /* Detach if no event given. */
  132.     setnilV(L->top++);
  133.     while (lua_next(L, -2)) {
  134.       L->top--;
  135.       if (tvisfunc(L->top) && funcV(L->top) == fn) {
  136.         setnilV(lj_tab_set(L, tabV(L->top-2), L->top-1));
  137.       }
  138.     }
  139.   }
  140. #endif
  141.   return 0;
  142. }

  144. LJLIB_PUSH(top-5) LJLIB_SET(os)
  145. LJLIB_PUSH(top-4) LJLIB_SET(arch)
  146. LJLIB_PUSH(top-3) LJLIB_SET(version_num)
  147. LJLIB_PUSH(top-2) LJLIB_SET(version)

  149. #include "lj_libdef.h"

  151. /* -- jit.util.* functions ------------------------------------------------ */

  153. ‌#define LJLIB_MODULE_jit_util

  155. /* -- Reflection API for Lua functions ------------------------------------ */

  157. /* Return prototype of first argument (Lua function or prototype object) */
  158. ‌static GCproto *check_Lproto(lua_State *L, int nolua)
  159. {
  160.   TValue *o = L->base;
  161.   if (L->top > o) {
  162.     if (tvisproto(o)) {
  163.       return protoV(o);
  164.     } else if (tvisfunc(o)) {
  165.       if (isluafunc(funcV(o)))
  166.         return funcproto(funcV(o));
  167.       else if (nolua)
  168.         return NULL;
  169.     }
  170.   }
  171.   lj_err_argt(L, 1, LUA_TFUNCTION);
  172.   return NULL;  /* unreachable */
  173. }

  175. ‌static void setintfield(lua_State *L, GCtab *t, const char *name, int32_t val)
  176. {
  177.   setintV(lj_tab_setstr(L, t, lj_str_newz(L, name)), val);
  178. }

  180. /* local info = jit.util.funcinfo(func [,pc]) */
  181. ‌LJLIB_CF(jit_util_funcinfo)
  182. {
  183.   GCproto *pt = check_Lproto(L, 1);
  184.   if (pt) {
  185.     BCPos pc = (BCPos)lj_lib_optint(L, 2, 0);
  186.     GCtab *t;
  187.     lua_createtable(L, 0, 16);  /* Increment hash size if fields are added. */
  188.     t = tabV(L->top-1);
  189.     setintfield(L, t, "linedefined", pt->firstline);
  190.     setintfield(L, t, "lastlinedefined", pt->firstline + pt->numline);
  191.     setintfield(L, t, "stackslots", pt->framesize);
  192.     setintfield(L, t, "params", pt->numparams);
  193.     setintfield(L, t, "bytecodes", (int32_t)pt->sizebc);
  194.     setintfield(L, t, "gcconsts", (int32_t)pt->sizekgc);
  195.     setintfield(L, t, "nconsts", (int32_t)pt->sizekn);
  196.     setintfield(L, t, "upvalues", (int32_t)pt->sizeuv);
  197.     if (pc < pt->sizebc)
  198.       setintfield(L, t, "currentline", lj_debug_line(pt, pc));
  199.     lua_pushboolean(L, (pt->flags & PROTO_VARARG));
  200.     lua_setfield(L, -2, "isvararg");
  201.     lua_pushboolean(L, (pt->flags & PROTO_CHILD));
  202.     lua_setfield(L, -2, "children");
  203.     setstrV(L, L->top++, proto_chunkname(pt));
  204.     lua_setfield(L, -2, "source");
  205.     lj_debug_pushloc(L, pt, pc);
  206.     lua_setfield(L, -2, "loc");
  207.   } else {
  208.     GCfunc *fn = funcV(L->base);
  209.     GCtab *t;
  210.     lua_createtable(L, 0, 4);  /* Increment hash size if fields are added. */
  211.     t = tabV(L->top-1);
  212.     if (!iscfunc(fn))
  213.       setintfield(L, t, "ffid", fn->c.ffid);
  214.     setintptrV(lj_tab_setstr(L, t, lj_str_newlit(L, "addr")),
  215.                (intptr_t)(void *)fn->c.f);
  216.     setintfield(L, t, "upvalues", fn->c.nupvalues);
  217.   }
  218.   return 1;
  219. }

  221. /* local ins, m = jit.util.funcbc(func, pc) */
  222. ‌LJLIB_CF(jit_util_funcbc)
  223. {
  224.   GCproto *pt = check_Lproto(L, 0);
  225.   BCPos pc = (BCPos)lj_lib_checkint(L, 2);
  226.   if (pc < pt->sizebc) {
  227.     BCIns ins = proto_bc(pt)[pc];
  228.     BCOp op = bc_op(ins);
  229.     lua_assert(op < BC__MAX);
  230.     setintV(L->top, ins);
  231.     setintV(L->top+1, lj_bc_mode[op]);
  232.     L->top += 2;
  233.     return 2;
  234.   }
  235.   return 0;
  236. }

  238. /* local k = jit.util.funck(func, idx) */
  239. ‌LJLIB_CF(jit_util_funck)
  240. {
  241.   GCproto *pt = check_Lproto(L, 0);
  242.   ptrdiff_t idx = (ptrdiff_t)lj_lib_checkint(L, 2);
  243.   if (idx >= 0) {
  244.     if (idx < (ptrdiff_t)pt->sizekn) {
  245.       copyTV(L, L->top-1, proto_knumtv(pt, idx));
  246.       return 1;
  247.     }
  248.   } else {
  249.     if (~idx < (ptrdiff_t)pt->sizekgc) {
  250.       GCobj *gc = proto_kgc(pt, idx);
  251.       setgcV(L, L->top-1, gc, ~gc->gch.gct);
  252.       return 1;
  253.     }
  254.   }
  255.   return 0;
  256. }

  258. /* local name = jit.util.funcuvname(func, idx) */
  259. ‌LJLIB_CF(jit_util_funcuvname)
  260. {
  261.   GCproto *pt = check_Lproto(L, 0);
  262.   uint32_t idx = (uint32_t)lj_lib_checkint(L, 2);
  263.   if (idx < pt->sizeuv) {
  264.     setstrV(L, L->top-1, lj_str_newz(L, lj_debug_uvname(pt, idx)));
  265.     return 1;
  266.   }
  267.   return 0;
  268. }

  270. /* -- Reflection API for traces ------------------------------------------- */

  272. #if LJ_HASJIT

  274. /* Check trace argument. Must not throw for non-existent trace numbers. */
  275. ‌static GCtrace *jit_checktrace(lua_State *L)
  276. {
  277.   TraceNo tr = (TraceNo)lj_lib_checkint(L, 1);
  278.   jit_State *J = L2J(L);
  279.   if (tr > 0 && tr < J->sizetrace)
  280.     return traceref(J, tr);
  281.   return NULL;
  282. }

  284. /* Names of link types. ORDER LJ_TRLINK */
  285. ‌static const char *const jit_trlinkname[] = {
  286.   "none", "root", "loop", "tail-recursion", "up-recursion", "down-recursion",
  287.   "interpreter", "return", "stitch"
  288. };

  290. /* local info = jit.util.traceinfo(tr) */
  291. ‌LJLIB_CF(jit_util_traceinfo)
  292. {
  293.   GCtrace *T = jit_checktrace(L);
  294.   if (T) {
  295.     GCtab *t;
  296.     lua_createtable(L, 0, 8);  /* Increment hash size if fields are added. */
  297.     t = tabV(L->top-1);
  298.     setintfield(L, t, "nins", (int32_t)T->nins - REF_BIAS - 1);
  299.     setintfield(L, t, "nk", REF_BIAS - (int32_t)T->nk);
  300.     setintfield(L, t, "link", T->link);
  301.     setintfield(L, t, "nexit", T->nsnap);
  302.     setstrV(L, L->top++, lj_str_newz(L, jit_trlinkname[T->linktype]));
  303.     lua_setfield(L, -2, "linktype");
  304.     /* There are many more fields. Add them only when needed. */
  305.     return 1;
  306.   }
  307.   return 0;
  308. }

  310. /* local m, ot, op1, op2, prev = jit.util.traceir(tr, idx) */
  311. ‌LJLIB_CF(jit_util_traceir)
  312. {
  313.   GCtrace *T = jit_checktrace(L);
  314.   IRRef ref = (IRRef)lj_lib_checkint(L, 2) + REF_BIAS;
  315.   if (T && ref >= REF_BIAS && ref < T->nins) {
  316.     IRIns *ir = &T->ir[ref];
  317.     int32_t m = lj_ir_mode[ir->o];
  318.     setintV(L->top-2, m);
  319.     setintV(L->top-1, ir->ot);
  320.     setintV(L->top++, (int32_t)ir->op1 - (irm_op1(m)==IRMref ? REF_BIAS : 0));
  321.     setintV(L->top++, (int32_t)ir->op2 - (irm_op2(m)==IRMref ? REF_BIAS : 0));
  322.     setintV(L->top++, ir->prev);
  323.     return 5;
  324.   }
  325.   return 0;
  326. }

  328. /* local k, t [, slot] = jit.util.tracek(tr, idx) */
  329. ‌LJLIB_CF(jit_util_tracek)
  330. {
  331.   GCtrace *T = jit_checktrace(L);
  332.   IRRef ref = (IRRef)lj_lib_checkint(L, 2) + REF_BIAS;
  333.   if (T && ref >= T->nk && ref < REF_BIAS) {
  334.     IRIns *ir = &T->ir[ref];
  335.     int32_t slot = -1;
  336.     if (ir->o == IR_KSLOT) {
  337.       slot = ir->op2;
  338.       ir = &T->ir[ir->op1];
  339.     }
  340. #if LJ_HASFFI
  341.     if (ir->o == IR_KINT64 && !ctype_ctsG(G(L))) {
  342.       ptrdiff_t oldtop = savestack(L, L->top);
  343.       luaopen_ffi(L);  /* Load FFI library on-demand. */
  344.       L->top = restorestack(L, oldtop);
  345.     }
  346. #endif
  347.     lj_ir_kvalue(L, L->top-2, ir);
  348.     setintV(L->top-1, (int32_t)irt_type(ir->t));
  349.     if (slot == -1)
  350.       return 2;
  351.     setintV(L->top++, slot);
  352.     return 3;
  353.   }
  354.   return 0;
  355. }

  357. /* local snap = jit.util.tracesnap(tr, sn) */
  358. ‌LJLIB_CF(jit_util_tracesnap)
  359. {
  360.   GCtrace *T = jit_checktrace(L);
  361.   SnapNo sn = (SnapNo)lj_lib_checkint(L, 2);
  362.   if (T && sn < T->nsnap) {
  363.     SnapShot *snap = &T->snap[sn];
  364.     SnapEntry *map = &T->snapmap[snap->mapofs];
  365.     MSize n, nent = snap->nent;
  366.     GCtab *t;
  367.     lua_createtable(L, nent+2, 0);
  368.     t = tabV(L->top-1);
  369.     setintV(lj_tab_setint(L, t, 0), (int32_t)snap->ref - REF_BIAS);
  370.     setintV(lj_tab_setint(L, t, 1), (int32_t)snap->nslots);
  371.     for (n = 0; n < nent; n++)
  372.       setintV(lj_tab_setint(L, t, (int32_t)(n+2)), (int32_t)map[n]);
  373.     setintV(lj_tab_setint(L, t, (int32_t)(nent+2)), (int32_t)SNAP(255, 0, 0));
  374.     return 1;
  375.   }
  376.   return 0;
  377. }

  379. /* local mcode, addr, loop = jit.util.tracemc(tr) */
  380. ‌LJLIB_CF(jit_util_tracemc)
  381. {
  382.   GCtrace *T = jit_checktrace(L);
  383.   if (T && T->mcode != NULL) {
  384.     setstrV(L, L->top-1, lj_str_new(L, (const char *)T->mcode, T->szmcode));
  385.     setintptrV(L->top++, (intptr_t)(void *)T->mcode);
  386.     setintV(L->top++, T->mcloop);
  387.     return 3;
  388.   }
  389.   return 0;
  390. }

  392. /* local addr = jit.util.traceexitstub([tr,] exitno) */
  393. ‌LJLIB_CF(jit_util_traceexitstub)
  394. {
  395. #ifdef EXITSTUBS_PER_GROUP
  396.   ExitNo exitno = (ExitNo)lj_lib_checkint(L, 1);
  397.   jit_State *J = L2J(L);
  398.   if (exitno < EXITSTUBS_PER_GROUP*LJ_MAX_EXITSTUBGR) {
  399.     setintptrV(L->top-1, (intptr_t)(void *)exitstub_addr(J, exitno));
  400.     return 1;
  401.   }
  402. #else
  403.   if (L->top > L->base+1) {  /* Don't throw for one-argument variant. */
  404.     GCtrace *T = jit_checktrace(L);
  405.     ExitNo exitno = (ExitNo)lj_lib_checkint(L, 2);
  406.     ExitNo maxexit = T->root ? T->nsnap+1 : T->nsnap;
  407.     if (T && T->mcode != NULL && exitno < maxexit) {
  408.       setintptrV(L->top-1, (intptr_t)(void *)exitstub_trace_addr(T, exitno));
  409.       return 1;
  410.     }
  411.   }
  412. #endif
  413.   return 0;
  414. }

  416. /* local addr = jit.util.ircalladdr(idx) */
  417. ‌LJLIB_CF(jit_util_ircalladdr)
  418. {
  419.   uint32_t idx = (uint32_t)lj_lib_checkint(L, 1);
  420.   if (idx < IRCALL__MAX) {
  421.     setintptrV(L->top-1, (intptr_t)(void *)lj_ir_callinfo[idx].func);
  422.     return 1;
  423.   }
  424.   return 0;
  425. }

  427. #endif

  429. #include "lj_libdef.h"

  431. ‌static int luaopen_jit_util(lua_State *L)
  432. {
  433.   LJ_LIB_REG(L, NULL, jit_util);
  434.   return 1;
  435. }

  437. /* -- jit.opt module ------------------------------------------------------ */

  439. #if LJ_HASJIT

  441. ‌#define LJLIB_MODULE_jit_opt

  443. /* Parse optimization level. */
  444. ‌static int jitopt_level(jit_State *J, const char *str)
  445. {
  446.   if (str[0] >= '0' && str[0] <= '9' && str[1] == '\0') {
  447.     uint32_t flags;
  448.     if (str[0] == '0') flags = JIT_F_OPT_0;
  449.     else if (str[0] == '1') flags = JIT_F_OPT_1;
  450.     else if (str[0] == '2') flags = JIT_F_OPT_2;
  451.     else flags = JIT_F_OPT_3;
  452.     J->flags = (J->flags & ~JIT_F_OPT_MASK) | flags;
  453.     return 1;  /* Ok. */
  454.   }
  455.   return 0;  /* No match. */
  456. }

  458. /* Parse optimization flag. */
  459. ‌static int jitopt_flag(jit_State *J, const char *str)
  460. {
  461.   const char *lst = JIT_F_OPTSTRING;
  462.   uint32_t opt;
  463.   int set = 1;
  464.   if (str[0] == '+') {
  465.     str++;
  466.   } else if (str[0] == '-') {
  467.     str++;
  468.     set = 0;
  469.   } else if (str[0] == 'n' && str[1] == 'o') {
  470.     str += str[2] == '-' ? 3 : 2;
  471.     set = 0;
  472.   }
  473.   for (opt = JIT_F_OPT_FIRST; ; opt <<= 1) {
  474.     size_t len = *(const uint8_t *)lst;
  475.     if (len == 0)
  476.       break;
  477.     if (strncmp(str, lst+1, len) == 0 && str[len] == '\0') {
  478.       if (set) J->flags |= opt; else J->flags &= ~opt;
  479.       return 1;  /* Ok. */
  480.     }
  481.     lst += 1+len;
  482.   }
  483.   return 0;  /* No match. */
  484. }

  486. /* Parse optimization parameter. */
  487. ‌static int jitopt_param(jit_State *J, const char *str)
  488. {
  489.   const char *lst = JIT_P_STRING;
  490.   int i;
  491.   for (i = 0; i < JIT_P__MAX; i++) {
  492.     size_t len = *(const uint8_t *)lst;
  493.     lua_assert(len != 0);
  494.     if (strncmp(str, lst+1, len) == 0 && str[len] == '=') {
  495.       int32_t n = 0;
  496.       const char *p = &str[len+1];
  497.       while (*p >= '0' && *p <= '9')
  498.         n = n*10 + (*p++ - '0');
  499.       if (*p) return 0;  /* Malformed number. */
  500.       J->param[i] = n;
  501.       if (i == JIT_P_hotloop)
  502.         lj_dispatch_init_hotcount(J2G(J));
  503.       return 1;  /* Ok. */
  504.     }
  505.     lst += 1+len;
  506.   }
  507.   return 0;  /* No match. */
  508. }

  510. /* jit.opt.start(flags...) */
  511. ‌LJLIB_CF(jit_opt_start)
  512. {
  513.   jit_State *J = L2J(L);
  514.   int nargs = (int)(L->top - L->base);
  515.   if (nargs == 0) {
  516.     J->flags = (J->flags & ~JIT_F_OPT_MASK) | JIT_F_OPT_DEFAULT;
  517.   } else {
  518.     int i;
  519.     for (i = 1; i <= nargs; i++) {
  520.       const char *str = strdata(lj_lib_checkstr(L, i));
  521.       if (!jitopt_level(J, str) &&
  522.           !jitopt_flag(J, str) &&
  523.           !jitopt_param(J, str))
  524.         lj_err_callerv(L, LJ_ERR_JITOPT, str);
  525.     }
  526.   }
  527.   return 0;
  528. }

  530. #include "lj_libdef.h"

  532. #endif

  534. /* -- jit.profile module -------------------------------------------------- */

  536. #if LJ_HASPROFILE

  538. ‌#define LJLIB_MODULE_jit_profile

  540. /* Not loaded by default, use: local profile = require("jit.profile") */

  542. ‌static const char KEY_PROFILE_THREAD = 't';
  543. ‌static const char KEY_PROFILE_FUNC = 'f';

  545. ‌static void jit_profile_callback(lua_State *L2, lua_State *L, int samples,
  546.                                  int vmstate)
  547. {
  548.   TValue key;
  549.   cTValue *tv;
  550.   setlightudV(&key, (void *)&KEY_PROFILE_FUNC);
  551.   tv = lj_tab_get(L, tabV(registry(L)), &key);
  552.   if (tvisfunc(tv)) {
  553.     char vmst = (char)vmstate;
  554.     int status;
  555.     setfuncV(L2, L2->top++, funcV(tv));
  556.     setthreadV(L2, L2->top++, L);
  557.     setintV(L2->top++, samples);
  558.     setstrV(L2, L2->top++, lj_str_new(L2, &vmst, 1));
  559.     status = lua_pcall(L2, 3, 0, 0);  /* callback(thread, samples, vmstate) */
  560.     if (status) {
  561.       if (G(L2)->panic) G(L2)->panic(L2);
  562.       exit(EXIT_FAILURE);
  563.     }
  564.     lj_trace_abort(G(L2));
  565.   }
  566. }

  568. /* profile.start(mode, cb) */
  569. ‌LJLIB_CF(jit_profile_start)
  570. {
  571.   GCtab *registry = tabV(registry(L));
  572.   GCstr *mode = lj_lib_optstr(L, 1);
  573.   GCfunc *func = lj_lib_checkfunc(L, 2);
  574.   lua_State *L2 = lua_newthread(L);  /* Thread that runs profiler callback. */
  575.   TValue key;
  576.   /* Anchor thread and function in registry. */
  577.   setlightudV(&key, (void *)&KEY_PROFILE_THREAD);
  578.   setthreadV(L, lj_tab_set(L, registry, &key), L2);
  579.   setlightudV(&key, (void *)&KEY_PROFILE_FUNC);
  580.   setfuncV(L, lj_tab_set(L, registry, &key), func);
  581.   lj_gc_anybarriert(L, registry);
  582.   luaJIT_profile_start(L, mode ? strdata(mode) : "",
  583.                        (luaJIT_profile_callback)jit_profile_callback, L2);
  584.   return 0;
  585. }

  587. /* profile.stop() */
  588. ‌LJLIB_CF(jit_profile_stop)
  589. {
  590.   GCtab *registry;
  591.   TValue key;
  592.   luaJIT_profile_stop(L);
  593.   registry = tabV(registry(L));
  594.   setlightudV(&key, (void *)&KEY_PROFILE_THREAD);
  595.   setnilV(lj_tab_set(L, registry, &key));
  596.   setlightudV(&key, (void *)&KEY_PROFILE_FUNC);
  597.   setnilV(lj_tab_set(L, registry, &key));
  598.   lj_gc_anybarriert(L, registry);
  599.   return 0;
  600. }

  602. /* dump = profile.dumpstack([thread,] fmt, depth) */
  603. ‌LJLIB_CF(jit_profile_dumpstack)
  604. {
  605.   lua_State *L2 = L;
  606.   int arg = 0;
  607.   size_t len;
  608.   int depth;
  609.   GCstr *fmt;
  610.   const char *p;
  611.   if (L->top > L->base && tvisthread(L->base)) {
  612.     L2 = threadV(L->base);
  613.     arg = 1;
  614.   }
  615.   fmt = lj_lib_checkstr(L, arg+1);
  616.   depth = lj_lib_checkint(L, arg+2);
  617.   p = luaJIT_profile_dumpstack(L2, strdata(fmt), depth, &len);
  618.   lua_pushlstring(L, p, len);
  619.   return 1;
  620. }

  622. #include "lj_libdef.h"

  624. ‌static int luaopen_jit_profile(lua_State *L)
  625. {
  626.   LJ_LIB_REG(L, NULL, jit_profile);
  627.   return 1;
  628. }

  630. #endif

  632. /* -- JIT compiler initialization ----------------------------------------- */

  634. #if LJ_HASJIT
  635. /* Default values for JIT parameters. */
  636. ‌static const int32_t jit_param_default[JIT_P__MAX+1] = {
  637. ‌#define JIT_PARAMINIT(len, name, value)        (value),
  638. JIT_PARAMDEF(JIT_PARAMINIT)
  639. ‌#undef JIT_PARAMINIT
  640.   0
  641. };
  642. #endif

  644. #if LJ_TARGET_ARM && LJ_TARGET_LINUX
  645. #include <sys/utsname.h>
  646. #endif

  648. /* Arch-dependent CPU detection. */
  649. ‌static uint32_t jit_cpudetect(lua_State *L)
  650. {
  651.   uint32_t flags = 0;
  652. #if LJ_TARGET_X86ORX64
  653.   uint32_t vendor[4];
  654.   uint32_t features[4];
  655.   if (lj_vm_cpuid(0, vendor) && lj_vm_cpuid(1, features)) {
  656. #if !LJ_HASJIT
  657. ‌#define JIT_F_SSE2        2
  658. #endif
  659.     flags |= ((features[3] >> 26)&1) * JIT_F_SSE2;
  660. #if LJ_HASJIT
  661.     flags |= ((features[2] >> 0)&1) * JIT_F_SSE3;
  662.     flags |= ((features[2] >> 19)&1) * JIT_F_SSE4_1;
  663.     if (vendor[2] == 0x6c65746e) {  /* Intel. */
  664.       if ((features[0] & 0x0fff0ff0) == 0x000106c0)  /* Atom. */
  665.         flags |= JIT_F_LEA_AGU;
  666.     } else if (vendor[2] == 0x444d4163) {  /* AMD. */
  667.       uint32_t fam = (features[0] & 0x0ff00f00);
  668.       if (fam >= 0x00000f00)  /* K8, K10. */
  669.         flags |= JIT_F_PREFER_IMUL;
  670.     }
  671. #endif
  672.   }
  673.   /* Check for required instruction set support on x86 (unnecessary on x64). */
  674. #if LJ_TARGET_X86
  675.   if (!(flags & JIT_F_SSE2))
  676.     luaL_error(L, "CPU with SSE2 required");
  677. #endif
  678. #elif LJ_TARGET_ARM
  679. #if LJ_HASJIT
  680.   int ver = LJ_ARCH_VERSION;  /* Compile-time ARM CPU detection. */
  681. #if LJ_TARGET_LINUX
  682.   if (ver < 70) {  /* Runtime ARM CPU detection. */
  683.     struct utsname ut;
  684.     uname(&ut);
  685.     if (strncmp(ut.machine, "armv", 4) == 0) {
  686.       if (ut.machine[4] >= '7')
  687.         ver = 70;
  688.       else if (ut.machine[4] == '6')
  689.         ver = 60;
  690.     }
  691.   }
  692. #endif
  693.   flags |= ver >= 70 ? JIT_F_ARMV7 :
  694.            ver >= 61 ? JIT_F_ARMV6T2_ :
  695.            ver >= 60 ? JIT_F_ARMV6_ : 0;
  696.   flags |= LJ_ARCH_HASFPU == 0 ? 0 : ver >= 70 ? JIT_F_VFPV3 : JIT_F_VFPV2;
  697. #endif
  698. #elif LJ_TARGET_ARM64
  699.   /* No optional CPU features to detect (for now). */
  700. #elif LJ_TARGET_PPC
  701. #if LJ_HASJIT
  702. #if LJ_ARCH_SQRT
  703.   flags |= JIT_F_SQRT;
  704. #endif
  705. #if LJ_ARCH_ROUND
  706.   flags |= JIT_F_ROUND;
  707. #endif
  708. #endif
  709. #elif LJ_TARGET_MIPS
  710. #if LJ_HASJIT
  711.   /* Compile-time MIPS CPU detection. */
  712. #if LJ_ARCH_VERSION >= 20
  713.   flags |= JIT_F_MIPS32R2;
  714. #endif
  715.   /* Runtime MIPS CPU detection. */
  716. #if defined(__GNUC__)
  717.   if (!(flags & JIT_F_MIPS32R2)) {
  718.     int x;
  719.     /* On MIPS32R1 rotr is treated as srl. rotr r2,r2,1 -> srl r2,r2,1. */
  720.     __asm__("li $2, 1\n\t.long 0x00221042\n\tmove %0, $2" : "=r"(x) : : "$2");
  721.     if (x) flags |= JIT_F_MIPS32R2;  /* Either 0x80000000 (R2) or 0 (R1). */
  722.   }
  723. #endif
  724. #endif
  725. #else
  726. #error "Missing CPU detection for this architecture"
  727. #endif
  728.   UNUSED(L);
  729.   return flags;
  730. }

  732. /* Initialize JIT compiler. */
  733. ‌static void jit_init(lua_State *L)
  734. {
  735.   uint32_t flags = jit_cpudetect(L);
  736. #if LJ_HASJIT
  737.   jit_State *J = L2J(L);
  738.   J->flags = flags | JIT_F_ON | JIT_F_OPT_DEFAULT;
  739.   memcpy(J->param, jit_param_default, sizeof(J->param));
  740.   lj_dispatch_update(G(L));
  741. #else
  742.   UNUSED(flags);
  743. #endif
  744. }

  746. ‌LUALIB_API int luaopen_jit(lua_State *L)
  747. {
  748.   jit_init(L);
  749.   lua_pushliteral(L, LJ_OS_NAME);
  750.   lua_pushliteral(L, LJ_ARCH_NAME);
  751.   lua_pushinteger(L, LUAJIT_VERSION_NUM);
  752.   lua_pushliteral(L, LUAJIT_VERSION);
  753.   LJ_LIB_REG(L, LUA_JITLIBNAME, jit);
  754. #if LJ_HASPROFILE
  755.   lj_lib_prereg(L, LUA_JITLIBNAME ".profile", luaopen_jit_profile,
  756.                 tabref(L->env));
  757. #endif
  758. #ifndef LUAJIT_DISABLE_JITUTIL
  759.   lj_lib_prereg(L, LUA_JITLIBNAME ".util", luaopen_jit_util, tabref(L->env));
  760. #endif
  761. #if LJ_HASJIT
  762.   LJ_LIB_REG(L, "jit.opt", jit_opt);
  763. #endif
  764.   L->top -= 2;
  765.   return 1;
  766. }

One Level Up Top Level