3 ** Copyright (C) 2005-2016 Mike Pall. See Copyright Notice in luajit.h
27 #include "lj_ircall.h"
29 #include "lj_target.h"
32 #include "lj_dispatch.h"
34 #include "lj_vmevent.h"
39 /* -- jit.* functions ----------------------------------------------------- */
41 #define LJLIB_MODULE_jit
43 static int setjitmode(lua_State
*L
, int mode
)
46 if (L
->base
== L
->top
|| tvisnil(L
->base
)) { /* jit.on/off/flush([nil]) */
47 mode
|= LUAJIT_MODE_ENGINE
;
49 /* jit.on/off/flush(func|proto, nil|true|false) */
50 if (tvisfunc(L
->base
) || tvisproto(L
->base
))
52 else if (!tvistrue(L
->base
)) /* jit.on/off/flush(true, nil|true|false) */
54 if (L
->base
+1 < L
->top
&& tvisbool(L
->base
+1))
55 mode
|= boolV(L
->base
+1) ? LUAJIT_MODE_ALLFUNC
: LUAJIT_MODE_ALLSUBFUNC
;
57 mode
|= LUAJIT_MODE_FUNC
;
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
);
63 lj_err_argt(L
, 1, LUA_TFUNCTION
);
70 return setjitmode(L
, LUAJIT_MODE_ON
);
75 return setjitmode(L
, LUAJIT_MODE_OFF
);
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
);
87 return setjitmode(L
, LUAJIT_MODE_FLUSH
);
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
,
95 for (; *str
; base
<<= 1, str
+= 1+*str
)
97 setstrV(L
, L
->top
++, lj_str_new(L
, str
+1, *(uint8_t *)str
));
104 jit_State
*J
= L2J(L
);
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
);
111 setboolV(L
->top
++, 0);
118 #ifdef LUAJIT_DISABLE_VMEVENT
119 luaL_error(L
, "vmevent API disabled");
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
);
127 while (*p
) h
= h
^ (lj_rol(h
, 6) + *p
++);
129 lua_rawseti(L
, -2, VMEVENT_HASHIDX(h
));
130 G(L
)->vmevmask
= VMEVENT_NOCACHE
; /* Invalidate cache. */
131 } else { /* Detach if no event given. */
133 while (lua_next(L
, -2)) {
135 if (tvisfunc(L
->top
) && funcV(L
->top
) == fn
) {
136 setnilV(lj_tab_set(L
, tabV(L
->top
-2), L
->top
-1));
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
)
164 } else if (tvisfunc(o
)) {
165 if (isluafunc(funcV(o
)))
166 return funcproto(funcV(o
));
171 lj_err_argt(L
, 1, LUA_TFUNCTION
);
172 return NULL
; /* unreachable */
175 static void setintfield(lua_State
*L
, GCtab
*t
, const char *name
, int32_t val
)
177 setintV(lj_tab_setstr(L
, t
, lj_str_newz(L
, name
)), val
);
180 /* local info = jit.util.funcinfo(func [,pc]) */
181 LJLIB_CF(jit_util_funcinfo
)
183 GCproto
*pt
= check_Lproto(L
, 1);
185 BCPos pc
= (BCPos
)lj_lib_optint(L
, 2, 0);
187 lua_createtable(L
, 0, 16); /* Increment hash size if fields are added. */
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
);
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");
208 GCfunc
*fn
= funcV(L
->base
);
210 lua_createtable(L
, 0, 4); /* Increment hash size if fields are added. */
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
);
221 /* local ins, m = jit.util.funcbc(func, pc) */
222 LJLIB_CF(jit_util_funcbc
)
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
]);
238 /* local k = jit.util.funck(func, idx) */
239 LJLIB_CF(jit_util_funck
)
241 GCproto
*pt
= check_Lproto(L
, 0);
242 ptrdiff_t idx
= (ptrdiff_t)lj_lib_checkint(L
, 2);
244 if (idx
< (ptrdiff_t)pt
->sizekn
) {
245 copyTV(L
, L
->top
-1, proto_knumtv(pt
, idx
));
249 if (~idx
< (ptrdiff_t)pt
->sizekgc
) {
250 GCobj
*gc
= proto_kgc(pt
, idx
);
251 setgcV(L
, L
->top
-1, gc
, ~gc
->gch
.gct
);
258 /* local name = jit.util.funcuvname(func, idx) */
259 LJLIB_CF(jit_util_funcuvname
)
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
)));
270 /* -- Reflection API for traces ------------------------------------------- */
274 /* Check trace argument. Must not throw for non-existent trace numbers. */
275 static GCtrace
*jit_checktrace(lua_State
*L
)
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
);
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"
290 /* local info = jit.util.traceinfo(tr) */
291 LJLIB_CF(jit_util_traceinfo
)
293 GCtrace
*T
= jit_checktrace(L
);
296 lua_createtable(L
, 0, 8); /* Increment hash size if fields are added. */
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. */
310 /* local m, ot, op1, op2, prev = jit.util.traceir(tr, idx) */
311 LJLIB_CF(jit_util_traceir
)
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
);
328 /* local k, t [, slot] = jit.util.tracek(tr, idx) */
329 LJLIB_CF(jit_util_tracek
)
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
];
336 if (ir
->o
== IR_KSLOT
) {
338 ir
= &T
->ir
[ir
->op1
];
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
);
347 lj_ir_kvalue(L
, L
->top
-2, ir
);
348 setintV(L
->top
-1, (int32_t)irt_type(ir
->t
));
351 setintV(L
->top
++, slot
);
357 /* local snap = jit.util.tracesnap(tr, sn) */
358 LJLIB_CF(jit_util_tracesnap
)
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
;
367 lua_createtable(L
, nent
+2, 0);
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));
379 /* local mcode, addr, loop = jit.util.tracemc(tr) */
380 LJLIB_CF(jit_util_tracemc
)
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
);
392 /* local addr = jit.util.traceexitstub([tr,] exitno) */
393 LJLIB_CF(jit_util_traceexitstub
)
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
));
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
));
416 /* local addr = jit.util.ircalladdr(idx) */
417 LJLIB_CF(jit_util_ircalladdr
)
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
);
429 #include "lj_libdef.h"
431 static int luaopen_jit_util(lua_State
*L
)
433 LJ_LIB_REG(L
, NULL
, jit_util
);
437 /* -- jit.opt module ------------------------------------------------------ */
441 #define LJLIB_MODULE_jit_opt
443 /* Parse optimization level. */
444 static int jitopt_level(jit_State
*J
, const char *str
)
446 if (str
[0] >= '0' && str
[0] <= '9' && str
[1] == '\0') {
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
;
455 return 0; /* No match. */
458 /* Parse optimization flag. */
459 static int jitopt_flag(jit_State
*J
, const char *str
)
461 const char *lst
= JIT_F_OPTSTRING
;
466 } else if (str
[0] == '-') {
469 } else if (str
[0] == 'n' && str
[1] == 'o') {
470 str
+= str
[2] == '-' ? 3 : 2;
473 for (opt
= JIT_F_OPT_FIRST
; ; opt
<<= 1) {
474 size_t len
= *(const uint8_t *)lst
;
477 if (strncmp(str
, lst
+1, len
) == 0 && str
[len
] == '\0') {
478 if (set
) J
->flags
|= opt
; else J
->flags
&= ~opt
;
483 return 0; /* No match. */
486 /* Parse optimization parameter. */
487 static int jitopt_param(jit_State
*J
, const char *str
)
489 const char *lst
= JIT_P_STRING
;
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
] == '=') {
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. */
501 if (i
== JIT_P_hotloop
)
502 lj_dispatch_init_hotcount(J2G(J
));
507 return 0; /* No match. */
510 /* jit.opt.start(flags...) */
511 LJLIB_CF(jit_opt_start
)
513 jit_State
*J
= L2J(L
);
514 int nargs
= (int)(L
->top
- L
->base
);
516 J
->flags
= (J
->flags
& ~JIT_F_OPT_MASK
) | JIT_F_OPT_DEFAULT
;
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
);
530 #include "lj_libdef.h"
534 /* -- jit.profile module -------------------------------------------------- */
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
,
550 setlightudV(&key
, (void *)&KEY_PROFILE_FUNC
);
551 tv
= lj_tab_get(L
, tabV(registry(L
)), &key
);
553 char vmst
= (char)vmstate
;
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) */
561 if (G(L2
)->panic
) G(L2
)->panic(L2
);
564 lj_trace_abort(G(L2
));
568 /* profile.start(mode, cb) */
569 LJLIB_CF(jit_profile_start
)
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. */
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
);
588 LJLIB_CF(jit_profile_stop
)
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
);
602 /* dump = profile.dumpstack([thread,] fmt, depth) */
603 LJLIB_CF(jit_profile_dumpstack
)
611 if (L
->top
> L
->base
&& tvisthread(L
->base
)) {
612 L2
= threadV(L
->base
);
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
);
622 #include "lj_libdef.h"
624 static int luaopen_jit_profile(lua_State
*L
)
626 LJ_LIB_REG(L
, NULL
, jit_profile
);
632 /* -- JIT compiler initialization ----------------------------------------- */
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
)
644 #if LJ_TARGET_ARM && LJ_TARGET_LINUX
645 #include <sys/utsname.h>
648 /* Arch-dependent CPU detection. */
649 static uint32_t jit_cpudetect(lua_State
*L
)
652 #if LJ_TARGET_X86ORX64
654 uint32_t features
[4];
655 if (lj_vm_cpuid(0, vendor
) && lj_vm_cpuid(1, features
)) {
659 flags
|= ((features
[3] >> 26)&1) * JIT_F_SSE2
;
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
;
673 /* Check for required instruction set support on x86 (unnecessary on x64). */
675 if (!(flags
& JIT_F_SSE2
))
676 luaL_error(L
, "CPU with SSE2 required");
680 int ver
= LJ_ARCH_VERSION
; /* Compile-time ARM CPU detection. */
682 if (ver
< 70) { /* Runtime ARM CPU detection. */
685 if (strncmp(ut
.machine
, "armv", 4) == 0) {
686 if (ut
.machine
[4] >= '7')
688 else if (ut
.machine
[4] == '6')
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
;
698 #elif LJ_TARGET_ARM64
699 /* No optional CPU features to detect (for now). */
706 flags
|= JIT_F_ROUND
;
711 /* Compile-time MIPS CPU detection. */
712 #if LJ_ARCH_VERSION >= 20
713 flags
|= JIT_F_MIPS32R2
;
715 /* Runtime MIPS CPU detection. */
716 #if defined(__GNUC__)
717 if (!(flags
& JIT_F_MIPS32R2
)) {
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). */
726 #error "Missing CPU detection for this architecture"
732 /* Initialize JIT compiler. */
733 static void jit_init(lua_State
*L
)
735 uint32_t flags
= jit_cpudetect(L
);
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
));
746 LUALIB_API
int luaopen_jit(lua_State
*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
);
755 lj_lib_prereg(L
, LUA_JITLIBNAME
".profile", luaopen_jit_profile
,
758 #ifndef LUAJIT_DISABLE_JITUTIL
759 lj_lib_prereg(L
, LUA_JITLIBNAME
".util", luaopen_jit_util
, tabref(L
->env
));
762 LJ_LIB_REG(L
, "jit.opt", jit_opt
);