Last active
May 31, 2021 06:28
-
-
Save losophy/50b5116ebf9e5cc0c51e86088cbca487 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m)) | |
const lu_byte luaP_opmodes[NUM_OPCODES] = { | |
/* T A B C mode opcode */ | |
opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_MOVE */ | |
,opmode(0, 1, OpArgK, OpArgN, iABx) /* OP_LOADK */ | |
,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_LOADBOOL */ | |
,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_LOADNIL */ | |
,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_GETUPVAL */ | |
,opmode(0, 1, OpArgK, OpArgN, iABx) /* OP_GETGLOBAL */ | |
,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_GETTABLE */ | |
,opmode(0, 0, OpArgK, OpArgN, iABx) /* OP_SETGLOBAL */ | |
,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_SETUPVAL */ | |
,opmode(0, 0, OpArgK, OpArgK, iABC) /* OP_SETTABLE */ | |
,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_NEWTABLE */ | |
,opmode(0, 1, OpArgR, OpArgK, iABC) /* OP_SELF */ | |
,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_ADD */ | |
,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_SUB */ | |
,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MUL */ | |
,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_DIV */ | |
,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_MOD */ | |
,opmode(0, 1, OpArgK, OpArgK, iABC) /* OP_POW */ | |
,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_UNM */ | |
,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_NOT */ | |
,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_LEN */ | |
,opmode(0, 1, OpArgR, OpArgR, iABC) /* OP_CONCAT */ | |
,opmode(0, 0, OpArgR, OpArgN, iAsBx) /* OP_JMP */ | |
,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_EQ */ | |
,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LT */ | |
,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LE */ | |
,opmode(1, 1, OpArgR, OpArgU, iABC) /* OP_TEST */ | |
,opmode(1, 1, OpArgR, OpArgU, iABC) /* OP_TESTSET */ | |
,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_CALL */ | |
,opmode(0, 1, OpArgU, OpArgU, iABC) /* OP_TAILCALL */ | |
,opmode(0, 0, OpArgU, OpArgN, iABC) /* OP_RETURN */ | |
,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORLOOP */ | |
,opmode(0, 1, OpArgR, OpArgN, iAsBx) /* OP_FORPREP */ | |
,opmode(1, 0, OpArgN, OpArgU, iABC) /* OP_TFORLOOP */ | |
,opmode(0, 0, OpArgU, OpArgU, iABC) /* OP_SETLIST */ | |
,opmode(0, 0, OpArgN, OpArgN, iABC) /* OP_CLOSE */ | |
,opmode(0, 1, OpArgU, OpArgN, iABx) /* OP_CLOSURE */ | |
,opmode(0, 1, OpArgU, OpArgN, iABC) /* OP_VARARG */ | |
}; | |
void luaV_execute (lua_State *L, int nexeccalls) { | |
LClosure *cl; | |
StkId base; | |
TValue *k; | |
const Instruction *pc; | |
reentry: /* entry point */ | |
lua_assert(isLua(L->ci)); | |
pc = L->savedpc; | |
cl = &clvalue(L->ci->func)->l; | |
base = L->base; | |
k = cl->p->k; | |
/* main loop of interpreter */ | |
for (;;) { | |
const Instruction i = *pc++; | |
StkId ra; | |
if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) && | |
(--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) { | |
traceexec(L, pc); | |
if (L->status == LUA_YIELD) { /* did hook yield? */ | |
L->savedpc = pc - 1; | |
return; | |
} | |
base = L->base; | |
} | |
/* warning!! several calls may realloc the stack and invalidate `ra' */ | |
ra = RA(i); | |
lua_assert(base == L->base && L->base == L->ci->base); | |
lua_assert(base <= L->top && L->top <= L->stack + L->stacksize); | |
lua_assert(L->top == L->ci->top || luaG_checkopenop(i)); | |
switch (GET_OPCODE(i)) { | |
case OP_MOVE: { | |
setobjs2s(L, ra, RB(i)); | |
continue; | |
} | |
case OP_LOADK: { | |
setobj2s(L, ra, KBx(i)); | |
continue; | |
} | |
case OP_LOADBOOL: { | |
setbvalue(ra, GETARG_B(i)); | |
if (GETARG_C(i)) pc++; /* skip next instruction (if C) */ | |
continue; | |
} | |
case OP_LOADNIL: { | |
TValue *rb = RB(i); | |
do { | |
setnilvalue(rb--); | |
} while (rb >= ra); | |
continue; | |
} | |
case OP_GETUPVAL: { | |
int b = GETARG_B(i); | |
setobj2s(L, ra, cl->upvals[b]->v); | |
continue; | |
} | |
case OP_GETGLOBAL: { | |
TValue g; | |
TValue *rb = KBx(i); | |
sethvalue(L, &g, cl->env); | |
lua_assert(ttisstring(rb)); | |
Protect(luaV_gettable(L, &g, rb, ra)); | |
continue; | |
} | |
case OP_GETTABLE: { | |
Protect(luaV_gettable(L, RB(i), RKC(i), ra)); | |
continue; | |
} | |
case OP_SETGLOBAL: { | |
TValue g; | |
sethvalue(L, &g, cl->env); | |
lua_assert(ttisstring(KBx(i))); | |
Protect(luaV_settable(L, &g, KBx(i), ra)); | |
continue; | |
} | |
case OP_SETUPVAL: { | |
UpVal *uv = cl->upvals[GETARG_B(i)]; | |
setobj(L, uv->v, ra); | |
luaC_barrier(L, uv, ra); | |
continue; | |
} | |
case OP_SETTABLE: { | |
Protect(luaV_settable(L, ra, RKB(i), RKC(i))); | |
continue; | |
} | |
case OP_NEWTABLE: { | |
int b = GETARG_B(i); | |
int c = GETARG_C(i); | |
sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c))); | |
Protect(luaC_checkGC(L)); | |
continue; | |
} | |
case OP_SELF: { | |
StkId rb = RB(i); | |
setobjs2s(L, ra+1, rb); | |
Protect(luaV_gettable(L, rb, RKC(i), ra)); | |
continue; | |
} | |
case OP_ADD: { | |
arith_op(luai_numadd, TM_ADD); | |
continue; | |
} | |
case OP_SUB: { | |
arith_op(luai_numsub, TM_SUB); | |
continue; | |
} | |
case OP_MUL: { | |
arith_op(luai_nummul, TM_MUL); | |
continue; | |
} | |
case OP_DIV: { | |
arith_op(luai_numdiv, TM_DIV); | |
continue; | |
} | |
case OP_MOD: { | |
arith_op(luai_nummod, TM_MOD); | |
continue; | |
} | |
case OP_POW: { | |
arith_op(luai_numpow, TM_POW); | |
continue; | |
} | |
case OP_UNM: { | |
TValue *rb = RB(i); | |
if (ttisnumber(rb)) { | |
lua_Number nb = nvalue(rb); | |
setnvalue(ra, luai_numunm(nb)); | |
} | |
else { | |
Protect(Arith(L, ra, rb, rb, TM_UNM)); | |
} | |
continue; | |
} | |
case OP_NOT: { | |
int res = l_isfalse(RB(i)); /* next assignment may change this value */ | |
setbvalue(ra, res); | |
continue; | |
} | |
case OP_LEN: { | |
const TValue *rb = RB(i); | |
switch (ttype(rb)) { | |
case LUA_TTABLE: { | |
setnvalue(ra, cast_num(luaH_getn(hvalue(rb)))); | |
break; | |
} | |
case LUA_TSTRING: { | |
setnvalue(ra, cast_num(tsvalue(rb)->len)); | |
break; | |
} | |
default: { /* try metamethod */ | |
Protect( | |
if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN)) | |
luaG_typeerror(L, rb, "get length of"); | |
) | |
} | |
} | |
continue; | |
} | |
case OP_CONCAT: { | |
int b = GETARG_B(i); | |
int c = GETARG_C(i); | |
Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L)); | |
setobjs2s(L, RA(i), base+b); | |
continue; | |
} | |
case OP_JMP: { | |
dojump(L, pc, GETARG_sBx(i)); | |
continue; | |
} | |
case OP_EQ: { | |
TValue *rb = RKB(i); | |
TValue *rc = RKC(i); | |
Protect( | |
if (equalobj(L, rb, rc) == GETARG_A(i)) | |
dojump(L, pc, GETARG_sBx(*pc)); | |
) | |
pc++; | |
continue; | |
} | |
case OP_LT: { | |
Protect( | |
if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i)) | |
dojump(L, pc, GETARG_sBx(*pc)); | |
) | |
pc++; | |
continue; | |
} | |
case OP_LE: { | |
Protect( | |
if (lessequal(L, RKB(i), RKC(i)) == GETARG_A(i)) | |
dojump(L, pc, GETARG_sBx(*pc)); | |
) | |
pc++; | |
continue; | |
} | |
case OP_TEST: { | |
if (l_isfalse(ra) != GETARG_C(i)) | |
dojump(L, pc, GETARG_sBx(*pc)); | |
pc++; | |
continue; | |
} | |
case OP_TESTSET: { | |
TValue *rb = RB(i); | |
if (l_isfalse(rb) != GETARG_C(i)) { | |
setobjs2s(L, ra, rb); | |
dojump(L, pc, GETARG_sBx(*pc)); | |
} | |
pc++; | |
continue; | |
} | |
case OP_CALL: { | |
int b = GETARG_B(i); | |
int nresults = GETARG_C(i) - 1; | |
if (b != 0) L->top = ra+b; /* else previous instruction set top */ | |
L->savedpc = pc; | |
switch (luaD_precall(L, ra, nresults)) { | |
case PCRLUA: { | |
nexeccalls++; | |
goto reentry; /* restart luaV_execute over new Lua function */ | |
} | |
case PCRC: { | |
/* it was a C function (`precall' called it); adjust results */ | |
if (nresults >= 0) L->top = L->ci->top; | |
base = L->base; | |
continue; | |
} | |
default: { | |
return; /* yield */ | |
} | |
} | |
} | |
case OP_TAILCALL: { | |
int b = GETARG_B(i); | |
if (b != 0) L->top = ra+b; /* else previous instruction set top */ | |
L->savedpc = pc; | |
lua_assert(GETARG_C(i) - 1 == LUA_MULTRET); | |
switch (luaD_precall(L, ra, LUA_MULTRET)) { | |
case PCRLUA: { | |
/* tail call: put new frame in place of previous one */ | |
CallInfo *ci = L->ci - 1; /* previous frame */ | |
int aux; | |
StkId func = ci->func; | |
StkId pfunc = (ci+1)->func; /* previous function index */ | |
if (L->openupval) luaF_close(L, ci->base); | |
L->base = ci->base = ci->func + ((ci+1)->base - pfunc); | |
for (aux = 0; pfunc+aux < L->top; aux++) /* move frame down */ | |
setobjs2s(L, func+aux, pfunc+aux); | |
ci->top = L->top = func+aux; /* correct top */ | |
lua_assert(L->top == L->base + clvalue(func)->l.p->maxstacksize); | |
ci->savedpc = L->savedpc; | |
ci->tailcalls++; /* one more call lost */ | |
L->ci--; /* remove new frame */ | |
goto reentry; | |
} | |
case PCRC: { /* it was a C function (`precall' called it) */ | |
base = L->base; | |
continue; | |
} | |
default: { | |
return; /* yield */ | |
} | |
} | |
} | |
case OP_RETURN: { | |
int b = GETARG_B(i); | |
if (b != 0) L->top = ra+b-1; | |
if (L->openupval) luaF_close(L, base); | |
L->savedpc = pc; | |
b = luaD_poscall(L, ra); | |
if (--nexeccalls == 0) /* was previous function running `here'? */ | |
return; /* no: return */ | |
else { /* yes: continue its execution */ | |
if (b) L->top = L->ci->top; | |
lua_assert(isLua(L->ci)); | |
lua_assert(GET_OPCODE(*((L->ci)->savedpc - 1)) == OP_CALL); | |
goto reentry; | |
} | |
} | |
case OP_FORLOOP: { | |
lua_Number step = nvalue(ra+2); | |
lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */ | |
lua_Number limit = nvalue(ra+1); | |
if (luai_numlt(0, step) ? luai_numle(idx, limit) | |
: luai_numle(limit, idx)) { | |
dojump(L, pc, GETARG_sBx(i)); /* jump back */ | |
setnvalue(ra, idx); /* update internal index... */ | |
setnvalue(ra+3, idx); /* ...and external index */ | |
} | |
continue; | |
} | |
case OP_FORPREP: { | |
const TValue *init = ra; | |
const TValue *plimit = ra+1; | |
const TValue *pstep = ra+2; | |
L->savedpc = pc; /* next steps may throw errors */ | |
if (!tonumber(init, ra)) | |
luaG_runerror(L, LUA_QL("for") " initial value must be a number"); | |
else if (!tonumber(plimit, ra+1)) | |
luaG_runerror(L, LUA_QL("for") " limit must be a number"); | |
else if (!tonumber(pstep, ra+2)) | |
luaG_runerror(L, LUA_QL("for") " step must be a number"); | |
setnvalue(ra, luai_numsub(nvalue(ra), nvalue(pstep))); | |
dojump(L, pc, GETARG_sBx(i)); | |
continue; | |
} | |
case OP_TFORLOOP: { | |
StkId cb = ra + 3; /* call base */ | |
setobjs2s(L, cb+2, ra+2); | |
setobjs2s(L, cb+1, ra+1); | |
setobjs2s(L, cb, ra); | |
L->top = cb+3; /* func. + 2 args (state and index) */ | |
Protect(luaD_call(L, cb, GETARG_C(i))); | |
L->top = L->ci->top; | |
cb = RA(i) + 3; /* previous call may change the stack */ | |
if (!ttisnil(cb)) { /* continue loop? */ | |
setobjs2s(L, cb-1, cb); /* save control variable */ | |
dojump(L, pc, GETARG_sBx(*pc)); /* jump back */ | |
} | |
pc++; | |
continue; | |
} | |
case OP_SETLIST: { | |
int n = GETARG_B(i); | |
int c = GETARG_C(i); | |
int last; | |
Table *h; | |
if (n == 0) { | |
n = cast_int(L->top - ra) - 1; | |
L->top = L->ci->top; | |
} | |
if (c == 0) c = cast_int(*pc++); | |
runtime_check(L, ttistable(ra)); | |
h = hvalue(ra); | |
last = ((c-1)*LFIELDS_PER_FLUSH) + n; | |
if (last > h->sizearray) /* needs more space? */ | |
luaH_resizearray(L, h, last); /* pre-alloc it at once */ | |
for (; n > 0; n--) { | |
TValue *val = ra+n; | |
setobj2t(L, luaH_setnum(L, h, last--), val); | |
luaC_barriert(L, h, val); | |
} | |
continue; | |
} | |
case OP_CLOSE: { | |
luaF_close(L, ra); | |
continue; | |
} | |
case OP_CLOSURE: { | |
Proto *p; | |
Closure *ncl; | |
int nup, j; | |
p = cl->p->p[GETARG_Bx(i)]; | |
nup = p->nups; | |
ncl = luaF_newLclosure(L, nup, cl->env); | |
ncl->l.p = p; | |
for (j=0; j<nup; j++, pc++) { | |
if (GET_OPCODE(*pc) == OP_GETUPVAL) | |
ncl->l.upvals[j] = cl->upvals[GETARG_B(*pc)]; | |
else { | |
lua_assert(GET_OPCODE(*pc) == OP_MOVE); | |
ncl->l.upvals[j] = luaF_findupval(L, base + GETARG_B(*pc)); | |
} | |
} | |
setclvalue(L, ra, ncl); | |
Protect(luaC_checkGC(L)); | |
continue; | |
} | |
case OP_VARARG: { | |
int b = GETARG_B(i) - 1; | |
int j; | |
CallInfo *ci = L->ci; | |
int n = cast_int(ci->base - ci->func) - cl->p->numparams - 1; | |
if (b == LUA_MULTRET) { | |
Protect(luaD_checkstack(L, n)); | |
ra = RA(i); /* previous call may change the stack */ | |
b = n; | |
L->top = ra + n; | |
} | |
for (j = 0; j < b; j++) { | |
if (j < n) { | |
setobjs2s(L, ra + j, ci->base - n + j); | |
} | |
else { | |
setnilvalue(ra + j); | |
} | |
} | |
continue; | |
} | |
} | |
} | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
** size and position of opcode arguments. | |
*/ | |
#define SIZE_C 9 | |
#define SIZE_B 9 | |
#define SIZE_Bx (SIZE_C + SIZE_B) | |
#define SIZE_A 8 | |
#define SIZE_OP 6 | |
#define POS_OP 0 | |
#define POS_A (POS_OP + SIZE_OP) | |
#define POS_C (POS_A + SIZE_A) | |
#define POS_B (POS_C + SIZE_C) | |
#define POS_Bx POS_C | |
/* | |
** limits for opcode arguments. | |
** we use (signed) int to manipulate most arguments, | |
** so they must fit in LUAI_BITSINT-1 bits (-1 for sign) | |
*/ | |
#if SIZE_Bx < LUAI_BITSINT-1 | |
#define MAXARG_Bx ((1<<SIZE_Bx)-1) | |
#define MAXARG_sBx (MAXARG_Bx>>1) /* `sBx' is signed */ | |
#else | |
#define MAXARG_Bx MAX_INT | |
#define MAXARG_sBx MAX_INT | |
#endif | |
#define MAXARG_A ((1<<SIZE_A)-1) | |
#define MAXARG_B ((1<<SIZE_B)-1) | |
#define MAXARG_C ((1<<SIZE_C)-1) | |
/* creates a mask with `n' 1 bits at position `p' */ | |
#define MASK1(n,p) ((~((~(Instruction)0)<<n))<<p) | |
/* creates a mask with `n' 0 bits at position `p' */ | |
#define MASK0(n,p) (~MASK1(n,p)) | |
/* | |
** the following macros help to manipulate instructions | |
*/ | |
#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | |
#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ | |
((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP)))) | |
#define GETARG_A(i) (cast(int, ((i)>>POS_A) & MASK1(SIZE_A,0))) | |
#define SETARG_A(i,u) ((i) = (((i)&MASK0(SIZE_A,POS_A)) | \ | |
((cast(Instruction, u)<<POS_A)&MASK1(SIZE_A,POS_A)))) | |
#define GETARG_B(i) (cast(int, ((i)>>POS_B) & MASK1(SIZE_B,0))) | |
#define SETARG_B(i,b) ((i) = (((i)&MASK0(SIZE_B,POS_B)) | \ | |
((cast(Instruction, b)<<POS_B)&MASK1(SIZE_B,POS_B)))) | |
#define GETARG_C(i) (cast(int, ((i)>>POS_C) & MASK1(SIZE_C,0))) | |
#define SETARG_C(i,b) ((i) = (((i)&MASK0(SIZE_C,POS_C)) | \ | |
((cast(Instruction, b)<<POS_C)&MASK1(SIZE_C,POS_C)))) | |
#define GETARG_Bx(i) (cast(int, ((i)>>POS_Bx) & MASK1(SIZE_Bx,0))) | |
#define SETARG_Bx(i,b) ((i) = (((i)&MASK0(SIZE_Bx,POS_Bx)) | \ | |
((cast(Instruction, b)<<POS_Bx)&MASK1(SIZE_Bx,POS_Bx)))) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment