src/lib_jit.c

   1 /*
   2 ** JIT library.
   3 ** Copyright (C) 2005-2014 Mike Pall. See Copyright Notice in luajit.h
   4 */
   5
   6 #define lib_jit_c
   7 #define LUA_LIB
   8
   9 #include "lua.h"
  10 #include "lauxlib.h"
  11 #include "lualib.h"
  12
  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"
  36
  37 #include "luajit.h"
  38
  39 /* -- jit.* functions ----------------------------------------------------- */
  40
  41 #define LJLIB_MODULE_jit
  42
  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 }
  67
  68 LJLIB_CF(jit_on)
  69 {
  70   return setjitmode(L, LUAJIT_MODE_ON);
  71 }
  72
  73 LJLIB_CF(jit_off)
  74 {
  75   return setjitmode(L, LUAJIT_MODE_OFF);
  76 }
  77
  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 }
  89
  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
 100
 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 }
 115
 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 }
 143
 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)
 148
 149 #include "lj_libdef.h"
 150
 151 /* -- jit.util.* functions ------------------------------------------------ */
 152
 153 #define LJLIB_MODULE_jit_util
 154
 155 /* -- Reflection API for Lua functions ------------------------------------ */
 156
 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 }
 174
 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 }
 179
 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 }
 220
 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 }
 237
 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 }
 257
 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 }
 269
 270 /* -- Reflection API for traces ------------------------------------------- */
 271
 272 #if LJ_HASJIT
 273
 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 }
 283
 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 };
 289
 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 }
 309
 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 }
 327
 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 }
 356
 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 }
 378
 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 }
 391
 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 }
 415
 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 }
 426
 427 #endif
 428
 429 #include "lj_libdef.h"
 430
 431 static int luaopen_jit_util(lua_State *L)
 432 {
 433   LJ_LIB_REG(L, NULL, jit_util);
 434   return 1;
 435 }
 436
 437 /* -- jit.opt module ------------------------------------------------------ */
 438
 439 #if LJ_HASJIT
 440
 441 #define LJLIB_MODULE_jit_opt
 442
 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 }
 457
 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 }
 485
 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 }
 509
 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 }
 529
 530 #include "lj_libdef.h"
 531
 532 #endif
 533
 534 /* -- jit.profile module -------------------------------------------------- */
 535
 536 #if LJ_HASPROFILE
 537
 538 #define LJLIB_MODULE_jit_profile
 539
 540 /* Not loaded by default, use: local profile = require("jit.profile") */
 541
 542 static const char KEY_PROFILE_THREAD = 't';
 543 static const char KEY_PROFILE_FUNC = 'f';
 544
 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 }
 567
 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 }
 586
 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 }
 601
 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 }
 621
 622 #include "lj_libdef.h"
 623
 624 static int luaopen_jit_profile(lua_State *L)
 625 {
 626   LJ_LIB_REG(L, NULL, jit_profile);
 627   return 1;
 628 }
 629
 630 #endif
 631
 632 /* -- JIT compiler initialization ----------------------------------------- */
 633
 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
 643
 644 #if LJ_TARGET_ARM && LJ_TARGET_LINUX
 645 #include <sys/utsname.h>
 646 #endif
 647
 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_PPC
 699 #if LJ_HASJIT
 700 #if LJ_ARCH_SQRT
 701   flags |= JIT_F_SQRT;
 702 #endif
 703 #if LJ_ARCH_ROUND
 704   flags |= JIT_F_ROUND;
 705 #endif
 706 #endif
 707 #elif LJ_TARGET_PPCSPE
 708   /* Nothing to do. */
 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 }
 731
 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 }
 745
 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 }
 767