mirrors/lua
1
0
Fork 0
mirror of https://github.com/lua/lua synced 2025-04-06 21:12:53 +03:00
Code Issues Packages Projects Releases Wiki Activity

'luaV_execute' keeps local copy of program counter and hook mask,

Browse Source 
to avoid excessive access to globals.
This commit is contained in:
Roberto Ierusalimschy 2017-05-05 14:16:11 -03:00
parent 4ce8d2047c
commit e8757a73e6
1 changed files with 62 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
lvm.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lvm.c,v 2.275 2017/04/30 20:43:26 roberto Exp roberto $ ** $Id: lvm.c,v 2.276 2017/05/04 13:32:01 roberto Exp roberto $
** Lua virtual machine ** Lua virtual machine
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -742,17 +742,37 @@ void luaV_finishOp (lua_State *L) {
ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i)) ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))
/* execute a jump instruction */
#define updatemask(L) (mask = L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT))
/*
** Execute a jump instruction. The 'updatemask' allows signals to stop
** tight loops. (Without it, the local copy of 'mask' could never change.)
*/
#define dojump(ci,i,e) \ #define dojump(ci,i,e) \
{ int a = GETARG_A(i); \ { int a = GETARG_A(i); \
if (a != 0) luaF_close(L, ci->u.l.base + a - 1); \ if (a != 0) luaF_close(L, ci->u.l.base + a - 1); \
ci->u.l.savedpc += GETARG_sBx(i) + e; } pc += GETARG_sBx(i) + e; updatemask(L); }
/* for test instructions, execute the jump instruction that follows it */ /* for test instructions, execute the jump instruction that follows it */
#define donextjump(ci) { i = *ci->u.l.savedpc; dojump(ci, i, 1); } #define donextjump(ci) { i = *pc; dojump(ci, i, 1); }
/*
** Whenever code can raise errors (including memory errors), the global
** 'pc' must be correct to report occasional errors.
*/
#define savepc(L) (ci->u.l.savedpc = pc)
#define Protect(x) { {x;}; base = ci->u.l.base; } /*
** Protect code that, in general, can raise errors, reallocate the
** stack, and change the hooks.
*/
#define Protect(code) \
{ savepc(L); {code;}; base = ci->u.l.base; updatemask(L); }
#define checkGC(L,c) \ #define checkGC(L,c) \
{ luaC_condGC(L, L->top = (c), /* limit of live values */ \ { luaC_condGC(L, L->top = (c), /* limit of live values */ \
@ -762,12 +782,9 @@ void luaV_finishOp (lua_State *L) {
/* fetch an instruction and prepare its execution */ /* fetch an instruction and prepare its execution */
#define vmfetch() { \ #define vmfetch() { \
i = *(ci->u.l.savedpc++); \ i = *(pc++); \
if (L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) \ if (mask) Protect(luaG_traceexec(L)); \
Protect(luaG_traceexec(L)); \
ra = RA(i); /* WARNING: any stack reallocation invalidates 'ra' */ \ ra = RA(i); /* WARNING: any stack reallocation invalidates 'ra' */ \
lua_assert(base == ci->u.l.base); \
lua_assert(base <= L->top && L->top < L->stack + L->stacksize); \
} }
#define vmdispatch(o) switch(o) #define vmdispatch(o) switch(o)
@ -795,18 +812,24 @@ void luaV_execute (lua_State *L) {
CallInfo *ci = L->ci; CallInfo *ci = L->ci;
LClosure *cl; LClosure *cl;
TValue *k; TValue *k;
StkId base; StkId base; /* local copy of 'ci->u.l.base' */
int mask; /* local copy of 'L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)' */
const Instruction *pc; /* local copy of 'ci->u.l.savedpc' */
ci->callstatus |= CIST_FRESH; /* fresh invocation of 'luaV_execute" */ ci->callstatus |= CIST_FRESH; /* fresh invocation of 'luaV_execute" */
newframe: /* reentry point when frame changes (call/return) */ newframe: /* reentry point when frame changes (call/return) */
lua_assert(ci == L->ci); lua_assert(ci == L->ci);
cl = clLvalue(ci->func); /* local reference to function's closure */ cl = clLvalue(ci->func); /* local reference to function's closure */
k = cl->p->k; /* local reference to function's constant table */ k = cl->p->k; /* local reference to function's constant table */
base = ci->u.l.base; /* local copy of function's base */ updatemask(L);
base = ci->u.l.base;
pc = ci->u.l.savedpc;
/* main loop of interpreter */ /* main loop of interpreter */
for (;;) { for (;;) {
Instruction i; Instruction i;
StkId ra; StkId ra;
vmfetch(); vmfetch();
lua_assert(base == ci->u.l.base);
lua_assert(base <= L->top && L->top < L->stack + L->stacksize);
vmdispatch (GET_OPCODE(i)) { vmdispatch (GET_OPCODE(i)) {
vmcase(OP_MOVE) { vmcase(OP_MOVE) {
setobjs2s(L, ra, RB(i)); setobjs2s(L, ra, RB(i));
@ -824,14 +847,14 @@ void luaV_execute (lua_State *L) {
} }
vmcase(OP_LOADKX) { vmcase(OP_LOADKX) {
TValue *rb; TValue *rb;
lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG); lua_assert(GET_OPCODE(*pc) == OP_EXTRAARG);
rb = k + GETARG_Ax(*ci->u.l.savedpc++); rb = k + GETARG_Ax(*pc++);
setobj2s(L, ra, rb); setobj2s(L, ra, rb);
vmbreak; vmbreak;
} }
vmcase(OP_LOADBOOL) { vmcase(OP_LOADBOOL) {
setbvalue(ra, GETARG_B(i)); setbvalue(ra, GETARG_B(i));
if (GETARG_C(i)) ci->u.l.savedpc++; /* skip next instruction (if C) */ if (GETARG_C(i)) pc++; /* skip next instruction (if C) */
vmbreak; vmbreak;
} }
vmcase(OP_LOADNIL) { vmcase(OP_LOADNIL) {
@ -933,7 +956,9 @@ void luaV_execute (lua_State *L) {
vmcase(OP_NEWTABLE) { vmcase(OP_NEWTABLE) {
int b = GETARG_B(i); int b = GETARG_B(i);
int c = GETARG_C(i); int c = GETARG_C(i);
Table *t = luaH_new(L); Table *t;
savepc(L); /* in case of allocation errors */
t = luaH_new(L);
sethvalue(L, ra, t); sethvalue(L, ra, t);
if (b != 0 || c != 0) if (b != 0 || c != 0)
luaH_resize(L, t, luaO_fb2int(b), luaO_fb2int(c)); luaH_resize(L, t, luaO_fb2int(b), luaO_fb2int(c));
@ -1173,7 +1198,7 @@ void luaV_execute (lua_State *L) {
TValue *rc = RKC(i); TValue *rc = RKC(i);
Protect( Protect(
if (luaV_equalobj(L, rb, rc) != GETARG_A(i)) if (luaV_equalobj(L, rb, rc) != GETARG_A(i))
ci->u.l.savedpc++; pc++;
else else
donextjump(ci); donextjump(ci);
) )
@ -1182,7 +1207,7 @@ void luaV_execute (lua_State *L) {
vmcase(OP_LT) { vmcase(OP_LT) {
Protect( Protect(
if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i)) if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i))
ci->u.l.savedpc++; pc++;
else else
donextjump(ci); donextjump(ci);
) )
@ -1191,7 +1216,7 @@ void luaV_execute (lua_State *L) {
vmcase(OP_LE) { vmcase(OP_LE) {
Protect( Protect(
if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i)) if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i))
ci->u.l.savedpc++; pc++;
else else
donextjump(ci); donextjump(ci);
) )
@ -1199,7 +1224,7 @@ void luaV_execute (lua_State *L) {
} }
vmcase(OP_TEST) { vmcase(OP_TEST) {
if (GETARG_C(i) ? l_isfalse(ra) : !l_isfalse(ra)) if (GETARG_C(i) ? l_isfalse(ra) : !l_isfalse(ra))
ci->u.l.savedpc++; pc++;
else else
donextjump(ci); donextjump(ci);
vmbreak; vmbreak;
@ -1207,7 +1232,7 @@ void luaV_execute (lua_State *L) {
vmcase(OP_TESTSET) { vmcase(OP_TESTSET) {
TValue *rb = RB(i); TValue *rb = RB(i);
if (GETARG_C(i) ? l_isfalse(rb) : !l_isfalse(rb)) if (GETARG_C(i) ? l_isfalse(rb) : !l_isfalse(rb))
ci->u.l.savedpc++; pc++;
else { else {
setobjs2s(L, ra, rb); setobjs2s(L, ra, rb);
donextjump(ci); donextjump(ci);
@ -1218,6 +1243,7 @@ void luaV_execute (lua_State *L) {
int b = GETARG_B(i); int b = GETARG_B(i);
int nresults = GETARG_C(i) - 1; int nresults = GETARG_C(i) - 1;
if (b != 0) L->top = ra+b; /* else previous instruction set top */ if (b != 0) L->top = ra+b; /* else previous instruction set top */
savepc(L);
if (luaD_precall(L, ra, nresults)) { /* C function? */ if (luaD_precall(L, ra, nresults)) { /* C function? */
if (nresults >= 0) if (nresults >= 0)
L->top = ci->top; /* adjust results */ L->top = ci->top; /* adjust results */
@ -1233,6 +1259,7 @@ void luaV_execute (lua_State *L) {
int b = GETARG_B(i); int b = GETARG_B(i);
if (b != 0) L->top = ra+b; /* else previous instruction set top */ if (b != 0) L->top = ra+b; /* else previous instruction set top */
lua_assert(GETARG_C(i) - 1 == LUA_MULTRET); lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);
savepc(L);
if (luaD_precall(L, ra, LUA_MULTRET)) { /* C function? */ if (luaD_precall(L, ra, LUA_MULTRET)) { /* C function? */
Protect((void)0); /* update 'base' */ Protect((void)0); /* update 'base' */
} }
@ -1263,6 +1290,7 @@ void luaV_execute (lua_State *L) {
vmcase(OP_RETURN) { vmcase(OP_RETURN) {
int b = GETARG_B(i); int b = GETARG_B(i);
if (cl->p->sizep > 0) luaF_close(L, base); if (cl->p->sizep > 0) luaF_close(L, base);
savepc(L);
b = luaD_poscall(L, ci, ra, (b != 0 ? b - 1 : cast_int(L->top - ra))); b = luaD_poscall(L, ci, ra, (b != 0 ? b - 1 : cast_int(L->top - ra)));
if (ci->callstatus & CIST_FRESH) /* local 'ci' still from callee */ if (ci->callstatus & CIST_FRESH) /* local 'ci' still from callee */
return; /* external invocation: return */ return; /* external invocation: return */
@ -1280,7 +1308,7 @@ void luaV_execute (lua_State *L) {
lua_Integer idx = intop(+, ivalue(ra), step); /* increment index */ lua_Integer idx = intop(+, ivalue(ra), step); /* increment index */
lua_Integer limit = ivalue(ra + 1); lua_Integer limit = ivalue(ra + 1);
if ((0 < step) ? (idx <= limit) : (limit <= idx)) { if ((0 < step) ? (idx <= limit) : (limit <= idx)) {
ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ pc += GETARG_sBx(i); /* jump back */
chgivalue(ra, idx); /* update internal index... */ chgivalue(ra, idx); /* update internal index... */
setivalue(ra + 3, idx); /* ...and external index */ setivalue(ra + 3, idx); /* ...and external index */
} }
@ -1291,11 +1319,12 @@ void luaV_execute (lua_State *L) {
lua_Number limit = fltvalue(ra + 1); lua_Number limit = fltvalue(ra + 1);
if (luai_numlt(0, step) ? luai_numle(idx, limit) if (luai_numlt(0, step) ? luai_numle(idx, limit)
: luai_numle(limit, idx)) { : luai_numle(limit, idx)) {
ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ pc += GETARG_sBx(i); /* jump back */
chgfltvalue(ra, idx); /* update internal index... */ chgfltvalue(ra, idx); /* update internal index... */
setfltvalue(ra + 3, idx); /* ...and external index */ setfltvalue(ra + 3, idx); /* ...and external index */
} }
} }
updatemask(L);
vmbreak; vmbreak;
} }
vmcase(OP_FORPREP) { vmcase(OP_FORPREP) {
@ -1313,6 +1342,7 @@ void luaV_execute (lua_State *L) {
} }
else { /* try making all values floats */ else { /* try making all values floats */
lua_Number ninit; lua_Number nlimit; lua_Number nstep; lua_Number ninit; lua_Number nlimit; lua_Number nstep;
savepc(L); /* in case of errors */
if (!tonumber(plimit, &nlimit)) if (!tonumber(plimit, &nlimit))
luaG_runerror(L, "'for' limit must be a number"); luaG_runerror(L, "'for' limit must be a number");
setfltvalue(plimit, nlimit); setfltvalue(plimit, nlimit);
@ -1323,7 +1353,7 @@ void luaV_execute (lua_State *L) {
luaG_runerror(L, "'for' initial value must be a number"); luaG_runerror(L, "'for' initial value must be a number");
setfltvalue(init, luai_numsub(L, ninit, nstep)); setfltvalue(init, luai_numsub(L, ninit, nstep));
} }
ci->u.l.savedpc += GETARG_sBx(i); pc += GETARG_sBx(i);
vmbreak; vmbreak;
} }
vmcase(OP_TFORCALL) { vmcase(OP_TFORCALL) {
@ -1334,7 +1364,7 @@ void luaV_execute (lua_State *L) {
L->top = cb + 3; /* func. + 2 args (state and index) */ L->top = cb + 3; /* func. + 2 args (state and index) */
Protect(luaD_call(L, cb, GETARG_C(i))); Protect(luaD_call(L, cb, GETARG_C(i)));
L->top = ci->top; L->top = ci->top;
i = *(ci->u.l.savedpc++); /* go to next instruction */ i = *(pc++); /* go to next instruction */
ra = RA(i); ra = RA(i);
lua_assert(GET_OPCODE(i) == OP_TFORLOOP); lua_assert(GET_OPCODE(i) == OP_TFORLOOP);
goto l_tforloop; goto l_tforloop;
@ -1343,7 +1373,7 @@ void luaV_execute (lua_State *L) {
l_tforloop: l_tforloop:
if (!ttisnil(ra + 1)) { /* continue loop? */ if (!ttisnil(ra + 1)) { /* continue loop? */
setobjs2s(L, ra, ra + 1); /* save control variable */ setobjs2s(L, ra, ra + 1); /* save control variable */
ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ pc += GETARG_sBx(i); /* jump back */
} }
vmbreak; vmbreak;
} }
@ -1354,11 +1384,12 @@ void luaV_execute (lua_State *L) {
Table *h; Table *h;
if (n == 0) n = cast_int(L->top - ra) - 1; if (n == 0) n = cast_int(L->top - ra) - 1;
if (c == 0) { if (c == 0) {
lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG); lua_assert(GET_OPCODE(*pc) == OP_EXTRAARG);
c = GETARG_Ax(*ci->u.l.savedpc++); c = GETARG_Ax(*pc++);
} }
h = hvalue(ra); h = hvalue(ra);
last = ((c-1)*LFIELDS_PER_FLUSH) + n; last = ((c-1)*LFIELDS_PER_FLUSH) + n;
savepc(L); /* in case of allocation errors */
if (last > h->sizearray) /* needs more space? */ if (last > h->sizearray) /* needs more space? */
luaH_resizearray(L, h, last); /* preallocate it at once */ luaH_resizearray(L, h, last); /* preallocate it at once */
for (; n > 0; n--) { for (; n > 0; n--) {
@ -1372,8 +1403,10 @@ void luaV_execute (lua_State *L) {
vmcase(OP_CLOSURE) { vmcase(OP_CLOSURE) {
Proto *p = cl->p->p[GETARG_Bx(i)]; Proto *p = cl->p->p[GETARG_Bx(i)];
LClosure *ncl = getcached(p, cl->upvals, base); /* cached closure */ LClosure *ncl = getcached(p, cl->upvals, base); /* cached closure */
if (ncl == NULL) /* no match? */ if (ncl == NULL) { /* no match? */
savepc(L); /* in case of allocation errors */
pushclosure(L, p, cl->upvals, base, ra); /* create a new one */ pushclosure(L, p, cl->upvals, base, ra); /* create a new one */
}
else else
setclLvalue(L, ra, ncl); /* push cashed closure */ setclLvalue(L, ra, ncl); /* push cashed closure */
checkGC(L, ra + 1); checkGC(L, ra + 1);