3 ** Copyright (C) 2005-2017 Mike Pall. See Copyright Notice in luajit.h
23 #include "lj_ircall.h"
25 #include "lj_target.h"
27 #include "lj_dispatch.h"
29 #include "lj_vmevent.h"
34 /* -- jit.* functions ----------------------------------------------------- */
36 #define LJLIB_MODULE_jit
38 static int setjitmode(lua_State
*L
, int mode
)
41 if (L
->base
== L
->top
|| tvisnil(L
->base
)) { /* jit.on/off/flush([nil]) */
42 mode
|= LUAJIT_MODE_ENGINE
;
44 /* jit.on/off/flush(func|proto, nil|true|false) */
45 if (tvisfunc(L
->base
) || tvisproto(L
->base
))
47 else if (!tvistrue(L
->base
)) /* jit.on/off/flush(true, nil|true|false) */
49 if (L
->base
+1 < L
->top
&& tvisbool(L
->base
+1))
50 mode
|= boolV(L
->base
+1) ? LUAJIT_MODE_ALLFUNC
: LUAJIT_MODE_ALLSUBFUNC
;
52 mode
|= LUAJIT_MODE_FUNC
;
54 if (luaJIT_setmode(L
, idx
, mode
) != 1) {
55 if ((mode
& LUAJIT_MODE_MASK
) == LUAJIT_MODE_ENGINE
)
56 lj_err_caller(L
, LJ_ERR_NOJIT
);
58 lj_err_argt(L
, 1, LUA_TFUNCTION
);
65 return setjitmode(L
, LUAJIT_MODE_ON
);
70 return setjitmode(L
, LUAJIT_MODE_OFF
);
76 if (L
->base
< L
->top
&& tvisnumber(L
->base
)) {
77 int traceno
= lj_lib_checkint(L
, 1);
78 luaJIT_setmode(L
, traceno
, LUAJIT_MODE_FLUSH
|LUAJIT_MODE_TRACE
);
82 return setjitmode(L
, LUAJIT_MODE_FLUSH
);
86 /* Push a string for every flag bit that is set. */
87 static void flagbits_to_strings(lua_State
*L
, uint32_t flags
, uint32_t base
,
90 for (; *str
; base
<<= 1, str
+= 1+*str
)
92 setstrV(L
, L
->top
++, lj_str_new(L
, str
+1, *(uint8_t *)str
));
99 jit_State
*J
= L2J(L
);
101 setboolV(L
->top
++, (J
->flags
& JIT_F_ON
) ? 1 : 0);
102 flagbits_to_strings(L
, J
->flags
, JIT_F_CPU_FIRST
, JIT_F_CPUSTRING
);
103 flagbits_to_strings(L
, J
->flags
, JIT_F_OPT_FIRST
, JIT_F_OPTSTRING
);
104 return (int)(L
->top
- L
->base
);
106 setboolV(L
->top
++, 0);
113 #ifdef LUAJIT_DISABLE_VMEVENT
114 luaL_error(L
, "vmevent API disabled");
116 GCfunc
*fn
= lj_lib_checkfunc(L
, 1);
117 GCstr
*s
= lj_lib_optstr(L
, 2);
118 luaL_findtable(L
, LUA_REGISTRYINDEX
, LJ_VMEVENTS_REGKEY
, LJ_VMEVENTS_HSIZE
);
119 if (s
) { /* Attach to given event. */
120 const uint8_t *p
= (const uint8_t *)strdata(s
);
122 while (*p
) h
= h
^ (lj_rol(h
, 6) + *p
++);
124 lua_rawseti(L
, -2, VMEVENT_HASHIDX(h
));
125 G(L
)->vmevmask
= VMEVENT_NOCACHE
; /* Invalidate cache. */
126 } else { /* Detach if no event given. */
128 while (lua_next(L
, -2)) {
130 if (tvisfunc(L
->top
) && funcV(L
->top
) == fn
) {
131 setnilV(lj_tab_set(L
, tabV(L
->top
-2), L
->top
-1));
139 LJLIB_PUSH(top
-5) LJLIB_SET(os
)
140 LJLIB_PUSH(top
-4) LJLIB_SET(arch
)
141 LJLIB_PUSH(top
-3) LJLIB_SET(version_num
)
142 LJLIB_PUSH(top
-2) LJLIB_SET(version
)
144 #include "lj_libdef.h"
146 /* -- jit.util.* functions ------------------------------------------------ */
148 #define LJLIB_MODULE_jit_util
150 /* -- Reflection API for Lua functions ------------------------------------ */
152 /* Return prototype of first argument (Lua function or prototype object) */
153 static GCproto
*check_Lproto(lua_State
*L
, int nolua
)
159 } else if (tvisfunc(o
)) {
160 if (isluafunc(funcV(o
)))
161 return funcproto(funcV(o
));
166 lj_err_argt(L
, 1, LUA_TFUNCTION
);
167 return NULL
; /* unreachable */
170 static void setintfield(lua_State
*L
, GCtab
*t
, const char *name
, int32_t val
)
172 setintV(lj_tab_setstr(L
, t
, lj_str_newz(L
, name
)), val
);
175 /* local info = jit.util.funcinfo(func [,pc]) */
176 LJLIB_CF(jit_util_funcinfo
)
178 GCproto
*pt
= check_Lproto(L
, 1);
180 BCPos pc
= (BCPos
)lj_lib_optint(L
, 2, 0);
182 lua_createtable(L
, 0, 16); /* Increment hash size if fields are added. */
184 setintfield(L
, t
, "linedefined", pt
->firstline
);
185 setintfield(L
, t
, "lastlinedefined", pt
->firstline
+ pt
->numline
);
186 setintfield(L
, t
, "stackslots", pt
->framesize
);
187 setintfield(L
, t
, "params", pt
->numparams
);
188 setintfield(L
, t
, "bytecodes", (int32_t)pt
->sizebc
);
189 setintfield(L
, t
, "gcconsts", (int32_t)pt
->sizekgc
);
190 setintfield(L
, t
, "nconsts", (int32_t)pt
->sizekn
);
191 setintfield(L
, t
, "upvalues", (int32_t)pt
->sizeuv
);
193 setintfield(L
, t
, "currentline", lj_debug_line(pt
, pc
));
194 lua_pushboolean(L
, (pt
->flags
& PROTO_VARARG
));
195 lua_setfield(L
, -2, "isvararg");
196 lua_pushboolean(L
, (pt
->flags
& PROTO_CHILD
));
197 lua_setfield(L
, -2, "children");
198 setstrV(L
, L
->top
++, proto_chunkname(pt
));
199 lua_setfield(L
, -2, "source");
200 lj_debug_pushloc(L
, pt
, pc
);
201 lua_setfield(L
, -2, "loc");
202 setprotoV(L
, lj_tab_setstr(L
, t
, lj_str_newlit(L
, "proto")), pt
);
204 GCfunc
*fn
= funcV(L
->base
);
206 lua_createtable(L
, 0, 4); /* Increment hash size if fields are added. */
209 setintfield(L
, t
, "ffid", fn
->c
.ffid
);
210 setintptrV(lj_tab_setstr(L
, t
, lj_str_newlit(L
, "addr")),
211 (intptr_t)(void *)fn
->c
.f
);
212 setintfield(L
, t
, "upvalues", fn
->c
.nupvalues
);
217 /* local ins, m = jit.util.funcbc(func, pc) */
218 LJLIB_CF(jit_util_funcbc
)
220 GCproto
*pt
= check_Lproto(L
, 0);
221 BCPos pc
= (BCPos
)lj_lib_checkint(L
, 2);
222 if (pc
< pt
->sizebc
) {
223 BCIns ins
= proto_bc(pt
)[pc
];
224 BCOp op
= bc_op(ins
);
225 lua_assert(op
< BC__MAX
);
226 setintV(L
->top
, ins
);
227 setintV(L
->top
+1, lj_bc_mode
[op
]);
234 /* local k = jit.util.funck(func, idx) */
235 LJLIB_CF(jit_util_funck
)
237 GCproto
*pt
= check_Lproto(L
, 0);
238 ptrdiff_t idx
= (ptrdiff_t)lj_lib_checkint(L
, 2);
240 if (idx
< (ptrdiff_t)pt
->sizekn
) {
241 copyTV(L
, L
->top
-1, proto_knumtv(pt
, idx
));
245 if (~idx
< (ptrdiff_t)pt
->sizekgc
) {
246 GCobj
*gc
= proto_kgc(pt
, idx
);
247 setgcV(L
, L
->top
-1, gc
, ~gc
->gch
.gct
);
254 /* local name = jit.util.funcuvname(func, idx) */
255 LJLIB_CF(jit_util_funcuvname
)
257 GCproto
*pt
= check_Lproto(L
, 0);
258 uint32_t idx
= (uint32_t)lj_lib_checkint(L
, 2);
259 if (idx
< pt
->sizeuv
) {
260 setstrV(L
, L
->top
-1, lj_str_newz(L
, lj_debug_uvname(pt
, idx
)));
266 /* -- Reflection API for traces ------------------------------------------- */
270 /* Check trace argument. Must not throw for non-existent trace numbers. */
271 static GCtrace
*jit_checktrace(lua_State
*L
)
273 TraceNo tr
= (TraceNo
)lj_lib_checkint(L
, 1);
274 jit_State
*J
= L2J(L
);
275 if (tr
> 0 && tr
< J
->sizetrace
)
276 return traceref(J
, tr
);
280 /* Names of link types. ORDER LJ_TRLINK */
281 static const char *const jit_trlinkname
[] = {
282 "none", "root", "loop", "tail-recursion", "up-recursion", "down-recursion",
283 "interpreter", "return"
286 /* local info = jit.util.traceinfo(tr) */
287 LJLIB_CF(jit_util_traceinfo
)
289 GCtrace
*T
= jit_checktrace(L
);
292 lua_createtable(L
, 0, 8); /* Increment hash size if fields are added. */
294 setintfield(L
, t
, "nins", (int32_t)T
->nins
- REF_BIAS
- 1);
295 setintfield(L
, t
, "nk", REF_BIAS
- (int32_t)T
->nk
);
296 setintfield(L
, t
, "link", T
->link
);
297 setintfield(L
, t
, "nexit", T
->nsnap
);
298 setstrV(L
, L
->top
++, lj_str_newz(L
, jit_trlinkname
[T
->linktype
]));
299 lua_setfield(L
, -2, "linktype");
300 /* There are many more fields. Add them only when needed. */
306 /* local m, ot, op1, op2, prev = jit.util.traceir(tr, idx) */
307 LJLIB_CF(jit_util_traceir
)
309 GCtrace
*T
= jit_checktrace(L
);
310 IRRef ref
= (IRRef
)lj_lib_checkint(L
, 2) + REF_BIAS
;
311 if (T
&& ref
>= REF_BIAS
&& ref
< T
->nins
) {
312 IRIns
*ir
= &T
->ir
[ref
];
313 int32_t m
= lj_ir_mode
[ir
->o
];
314 setintV(L
->top
-2, m
);
315 setintV(L
->top
-1, ir
->ot
);
316 setintV(L
->top
++, (int32_t)ir
->op1
- (irm_op1(m
)==IRMref
? REF_BIAS
: 0));
317 setintV(L
->top
++, (int32_t)ir
->op2
- (irm_op2(m
)==IRMref
? REF_BIAS
: 0));
318 setintV(L
->top
++, ir
->prev
);
324 /* local k, t [, slot] = jit.util.tracek(tr, idx) */
325 LJLIB_CF(jit_util_tracek
)
327 GCtrace
*T
= jit_checktrace(L
);
328 IRRef ref
= (IRRef
)lj_lib_checkint(L
, 2) + REF_BIAS
;
329 if (T
&& ref
>= T
->nk
&& ref
< REF_BIAS
) {
330 IRIns
*ir
= &T
->ir
[ref
];
332 if (ir
->o
== IR_KSLOT
) {
334 ir
= &T
->ir
[ir
->op1
];
336 lj_ir_kvalue(L
, L
->top
-2, ir
);
337 setintV(L
->top
-1, (int32_t)irt_type(ir
->t
));
340 setintV(L
->top
++, slot
);
346 /* local snap = jit.util.tracesnap(tr, sn) */
347 LJLIB_CF(jit_util_tracesnap
)
349 GCtrace
*T
= jit_checktrace(L
);
350 SnapNo sn
= (SnapNo
)lj_lib_checkint(L
, 2);
351 if (T
&& sn
< T
->nsnap
) {
352 SnapShot
*snap
= &T
->snap
[sn
];
353 SnapEntry
*map
= &T
->snapmap
[snap
->mapofs
];
354 MSize n
, nent
= snap
->nent
;
356 lua_createtable(L
, nent
+2, 0);
358 setintV(lj_tab_setint(L
, t
, 0), (int32_t)snap
->ref
- REF_BIAS
);
359 setintV(lj_tab_setint(L
, t
, 1), (int32_t)snap
->nslots
);
360 for (n
= 0; n
< nent
; n
++)
361 setintV(lj_tab_setint(L
, t
, (int32_t)(n
+2)), (int32_t)map
[n
]);
362 setintV(lj_tab_setint(L
, t
, (int32_t)(nent
+2)), (int32_t)SNAP(255, 0, 0));
368 /* local mcode, addr, loop = jit.util.tracemc(tr) */
369 LJLIB_CF(jit_util_tracemc
)
371 GCtrace
*T
= jit_checktrace(L
);
372 if (T
&& T
->mcode
!= NULL
) {
373 setstrV(L
, L
->top
-1, lj_str_new(L
, (const char *)T
->mcode
, T
->szmcode
));
374 setintptrV(L
->top
++, (intptr_t)(void *)T
->mcode
);
375 setintV(L
->top
++, T
->mcloop
);
381 /* local addr = jit.util.traceexitstub([tr,] exitno) */
382 LJLIB_CF(jit_util_traceexitstub
)
384 #ifdef EXITSTUBS_PER_GROUP
385 ExitNo exitno
= (ExitNo
)lj_lib_checkint(L
, 1);
386 jit_State
*J
= L2J(L
);
387 if (exitno
< EXITSTUBS_PER_GROUP
*LJ_MAX_EXITSTUBGR
) {
388 setintptrV(L
->top
-1, (intptr_t)(void *)exitstub_addr(J
, exitno
));
392 if (L
->top
> L
->base
+1) { /* Don't throw for one-argument variant. */
393 GCtrace
*T
= jit_checktrace(L
);
394 ExitNo exitno
= (ExitNo
)lj_lib_checkint(L
, 2);
395 ExitNo maxexit
= T
->root
? T
->nsnap
+1 : T
->nsnap
;
396 if (T
&& T
->mcode
!= NULL
&& exitno
< maxexit
) {
397 setintptrV(L
->top
-1, (intptr_t)(void *)exitstub_trace_addr(T
, exitno
));
405 /* local addr = jit.util.ircalladdr(idx) */
406 LJLIB_CF(jit_util_ircalladdr
)
408 uint32_t idx
= (uint32_t)lj_lib_checkint(L
, 1);
409 if (idx
< IRCALL__MAX
) {
410 setintptrV(L
->top
-1, (intptr_t)(void *)lj_ir_callinfo
[idx
].func
);
418 #include "lj_libdef.h"
420 /* -- jit.opt module ------------------------------------------------------ */
424 #define LJLIB_MODULE_jit_opt
426 /* Parse optimization level. */
427 static int jitopt_level(jit_State
*J
, const char *str
)
429 if (str
[0] >= '0' && str
[0] <= '9' && str
[1] == '\0') {
431 if (str
[0] == '0') flags
= JIT_F_OPT_0
;
432 else if (str
[0] == '1') flags
= JIT_F_OPT_1
;
433 else if (str
[0] == '2') flags
= JIT_F_OPT_2
;
434 else flags
= JIT_F_OPT_3
;
435 J
->flags
= (J
->flags
& ~JIT_F_OPT_MASK
) | flags
;
438 return 0; /* No match. */
441 /* Parse optimization flag. */
442 static int jitopt_flag(jit_State
*J
, const char *str
)
444 const char *lst
= JIT_F_OPTSTRING
;
449 } else if (str
[0] == '-') {
452 } else if (str
[0] == 'n' && str
[1] == 'o') {
453 str
+= str
[2] == '-' ? 3 : 2;
456 for (opt
= JIT_F_OPT_FIRST
; ; opt
<<= 1) {
457 size_t len
= *(const uint8_t *)lst
;
460 if (strncmp(str
, lst
+1, len
) == 0 && str
[len
] == '\0') {
461 if (set
) J
->flags
|= opt
; else J
->flags
&= ~opt
;
466 return 0; /* No match. */
469 /* Parse optimization parameter. */
470 static int jitopt_param(jit_State
*J
, const char *str
)
472 const char *lst
= JIT_P_STRING
;
474 for (i
= 0; i
< JIT_P__MAX
; i
++) {
475 size_t len
= *(const uint8_t *)lst
;
476 lua_assert(len
!= 0);
477 if (strncmp(str
, lst
+1, len
) == 0 && str
[len
] == '=') {
479 const char *p
= &str
[len
+1];
480 while (*p
>= '0' && *p
<= '9')
481 n
= n
*10 + (*p
++ - '0');
482 if (*p
) return 0; /* Malformed number. */
484 if (i
== JIT_P_hotloop
)
485 lj_dispatch_init_hotcount(J2G(J
));
490 return 0; /* No match. */
493 /* jit.opt.start(flags...) */
494 LJLIB_CF(jit_opt_start
)
496 jit_State
*J
= L2J(L
);
497 int nargs
= (int)(L
->top
- L
->base
);
499 J
->flags
= (J
->flags
& ~JIT_F_OPT_MASK
) | JIT_F_OPT_DEFAULT
;
502 for (i
= 1; i
<= nargs
; i
++) {
503 const char *str
= strdata(lj_lib_checkstr(L
, i
));
504 if (!jitopt_level(J
, str
) &&
505 !jitopt_flag(J
, str
) &&
506 !jitopt_param(J
, str
))
507 lj_err_callerv(L
, LJ_ERR_JITOPT
, str
);
513 #include "lj_libdef.h"
517 /* -- JIT compiler initialization ----------------------------------------- */
520 /* Default values for JIT parameters. */
521 static const int32_t jit_param_default
[JIT_P__MAX
+1] = {
522 #define JIT_PARAMINIT(len, name, value) (value),
523 JIT_PARAMDEF(JIT_PARAMINIT
)
529 #if LJ_TARGET_ARM && LJ_TARGET_LINUX
530 #include <sys/utsname.h>
533 /* Arch-dependent CPU detection. */
534 static uint32_t jit_cpudetect(lua_State
*L
)
537 #if LJ_TARGET_X86ORX64
539 uint32_t features
[4];
540 if (lj_vm_cpuid(0, vendor
) && lj_vm_cpuid(1, features
)) {
545 flags
|= ((features
[3] >> 15)&1) * JIT_F_CMOV
;
546 flags
|= ((features
[3] >> 26)&1) * JIT_F_SSE2
;
548 flags
|= ((features
[2] >> 0)&1) * JIT_F_SSE3
;
549 flags
|= ((features
[2] >> 19)&1) * JIT_F_SSE4_1
;
550 if (vendor
[2] == 0x6c65746e) { /* Intel. */
551 if ((features
[0] & 0x0ff00f00) == 0x00000f00) /* P4. */
552 flags
|= JIT_F_P4
; /* Currently unused. */
553 else if ((features
[0] & 0x0fff0ff0) == 0x000106c0) /* Atom. */
554 flags
|= JIT_F_LEA_AGU
;
555 } else if (vendor
[2] == 0x444d4163) { /* AMD. */
556 uint32_t fam
= (features
[0] & 0x0ff00f00);
557 if (fam
== 0x00000f00) /* K8. */
558 flags
|= JIT_F_SPLIT_XMM
;
559 if (fam
>= 0x00000f00) /* K8, K10. */
560 flags
|= JIT_F_PREFER_IMUL
;
564 /* Check for required instruction set support on x86 (unnecessary on x64). */
566 #if !defined(LUAJIT_CPU_NOCMOV)
567 if (!(flags
& JIT_F_CMOV
))
568 luaL_error(L
, "CPU not supported");
570 #if defined(LUAJIT_CPU_SSE2)
571 if (!(flags
& JIT_F_SSE2
))
572 luaL_error(L
, "CPU does not support SSE2 (recompile without -DLUAJIT_CPU_SSE2)");
577 int ver
= LJ_ARCH_VERSION
; /* Compile-time ARM CPU detection. */
579 if (ver
< 70) { /* Runtime ARM CPU detection. */
582 if (strncmp(ut
.machine
, "armv", 4) == 0) {
583 if (ut
.machine
[4] >= '7')
585 else if (ut
.machine
[4] == '6')
590 flags
|= ver
>= 70 ? JIT_F_ARMV7
:
591 ver
>= 61 ? JIT_F_ARMV6T2_
:
592 ver
>= 60 ? JIT_F_ARMV6_
: 0;
593 flags
|= LJ_ARCH_HASFPU
== 0 ? 0 : ver
>= 70 ? JIT_F_VFPV3
: JIT_F_VFPV2
;
601 flags
|= JIT_F_ROUND
;
604 #elif LJ_TARGET_PPCSPE
608 /* Compile-time MIPS CPU detection. */
609 #if LJ_ARCH_VERSION >= 20
610 flags
|= JIT_F_MIPS32R2
;
612 /* Runtime MIPS CPU detection. */
613 #if defined(__GNUC__)
614 if (!(flags
& JIT_F_MIPS32R2
)) {
616 /* On MIPS32R1 rotr is treated as srl. rotr r2,r2,1 -> srl r2,r2,1. */
617 __asm__("li $2, 1\n\t.long 0x00221042\n\tmove %0, $2" : "=r"(x
) : : "$2");
618 if (x
) flags
|= JIT_F_MIPS32R2
; /* Either 0x80000000 (R2) or 0 (R1). */
623 #error "Missing CPU detection for this architecture"
629 /* Initialize JIT compiler. */
630 static void jit_init(lua_State
*L
)
632 uint32_t flags
= jit_cpudetect(L
);
634 jit_State
*J
= L2J(L
);
636 /* Silently turn off the JIT compiler on CPUs without SSE2. */
637 if ((flags
& JIT_F_SSE2
))
639 J
->flags
= flags
| JIT_F_ON
| JIT_F_OPT_DEFAULT
;
640 memcpy(J
->param
, jit_param_default
, sizeof(J
->param
));
641 lj_dispatch_update(G(L
));
647 LUALIB_API
int luaopen_jit(lua_State
*L
)
649 lua_pushliteral(L
, LJ_OS_NAME
);
650 lua_pushliteral(L
, LJ_ARCH_NAME
);
651 lua_pushinteger(L
, LUAJIT_VERSION_NUM
);
652 lua_pushliteral(L
, LUAJIT_VERSION
);
653 LJ_LIB_REG(L
, LUA_JITLIBNAME
, jit
);
654 #ifndef LUAJIT_DISABLE_JITUTIL
655 LJ_LIB_REG(L
, "jit.util", jit_util
);
658 LJ_LIB_REG(L
, "jit.opt", jit_opt
);