OpenWrt – Rev 1
?pathlinks?
--- a/src/lvm.c
+++ b/src/lvm.c
@@ -31,6 +31,9 @@
/* limit for table tag-method chains (to avoid loops) */
#define MAXTAGLOOP 100
+#ifdef __GNUC__
+#define COMPUTED_GOTO 1
+#endif
/*
* If 'obj' is a string, it is tried to be interpreted as a number.
@@ -568,12 +571,63 @@ static inline int arith_mode( const TVal
ARITH_OP1_END
#endif
+#ifdef COMPUTED_GOTO
+#define OPCODE_TARGET(op) DO_OP_##op:
+#define CALL_OPCODE(op) goto *opcodes[op];
+#define OPCODE_PTR(op) [OP_##op] = &&DO_OP_##op
+#else
+#define OPCODE_TARGET(op) case OP_##op:
+#define CALL_OPCODE(op) switch (op)
+#endif
+
void luaV_execute (lua_State *L, int nexeccalls) {
LClosure *cl;
StkId base;
TValue *k;
const Instruction *pc;
+#ifdef COMPUTED_GOTO
+ static const void *opcodes[] = {
+ OPCODE_PTR(MOVE),
+ OPCODE_PTR(LOADK),
+ OPCODE_PTR(LOADBOOL),
+ OPCODE_PTR(LOADNIL),
+ OPCODE_PTR(GETUPVAL),
+ OPCODE_PTR(GETGLOBAL),
+ OPCODE_PTR(GETTABLE),
+ OPCODE_PTR(SETGLOBAL),
+ OPCODE_PTR(SETUPVAL),
+ OPCODE_PTR(SETTABLE),
+ OPCODE_PTR(NEWTABLE),
+ OPCODE_PTR(SELF),
+ OPCODE_PTR(ADD),
+ OPCODE_PTR(SUB),
+ OPCODE_PTR(MUL),
+ OPCODE_PTR(DIV),
+ OPCODE_PTR(MOD),
+ OPCODE_PTR(POW),
+ OPCODE_PTR(UNM),
+ OPCODE_PTR(NOT),
+ OPCODE_PTR(LEN),
+ OPCODE_PTR(CONCAT),
+ OPCODE_PTR(JMP),
+ OPCODE_PTR(EQ),
+ OPCODE_PTR(LT),
+ OPCODE_PTR(LE),
+ OPCODE_PTR(TEST),
+ OPCODE_PTR(TESTSET),
+ OPCODE_PTR(CALL),
+ OPCODE_PTR(TAILCALL),
+ OPCODE_PTR(RETURN),
+ OPCODE_PTR(FORLOOP),
+ OPCODE_PTR(FORPREP),
+ OPCODE_PTR(TFORLOOP),
+ OPCODE_PTR(SETLIST),
+ OPCODE_PTR(CLOSE),
+ OPCODE_PTR(CLOSURE),
+ OPCODE_PTR(VARARG)
+ };
+#endif
reentry: /* entry point */
lua_assert(isLua(L->ci));
pc = L->savedpc;
@@ -598,33 +652,33 @@ void luaV_execute (lua_State *L, int nex
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: {
+ CALL_OPCODE(GET_OPCODE(i)) {
+ OPCODE_TARGET(MOVE) {
setobjs2s(L, ra, RB(i));
continue;
}
- case OP_LOADK: {
+ OPCODE_TARGET(LOADK) {
setobj2s(L, ra, KBx(i));
continue;
}
- case OP_LOADBOOL: {
+ OPCODE_TARGET(LOADBOOL) {
setbvalue(ra, GETARG_B(i));
if (GETARG_C(i)) pc++; /* skip next instruction (if C) */
continue;
}
- case OP_LOADNIL: {
+ OPCODE_TARGET(LOADNIL) {
TValue *rb = RB(i);
do {
setnilvalue(rb--);
} while (rb >= ra);
continue;
}
- case OP_GETUPVAL: {
+ OPCODE_TARGET(GETUPVAL) {
int b = GETARG_B(i);
setobj2s(L, ra, cl->upvals[b]->v);
continue;
}
- case OP_GETGLOBAL: {
+ OPCODE_TARGET(GETGLOBAL) {
TValue g;
TValue *rb = KBx(i);
sethvalue(L, &g, cl->env);
@@ -632,88 +686,88 @@ void luaV_execute (lua_State *L, int nex
Protect(luaV_gettable(L, &g, rb, ra));
continue;
}
- case OP_GETTABLE: {
+ OPCODE_TARGET(GETTABLE) {
Protect(luaV_gettable(L, RB(i), RKC(i), ra));
continue;
}
- case OP_SETGLOBAL: {
+ OPCODE_TARGET(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: {
+ OPCODE_TARGET(SETUPVAL) {
UpVal *uv = cl->upvals[GETARG_B(i)];
setobj(L, uv->v, ra);
luaC_barrier(L, uv, ra);
continue;
}
- case OP_SETTABLE: {
+ OPCODE_TARGET(SETTABLE) {
Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
continue;
}
- case OP_NEWTABLE: {
+ OPCODE_TARGET(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: {
+ OPCODE_TARGET(SELF) {
StkId rb = RB(i);
setobjs2s(L, ra+1, rb);
Protect(luaV_gettable(L, rb, RKC(i), ra));
continue;
}
- case OP_ADD: {
+ OPCODE_TARGET(ADD) {
TValue *rb = RKB(i), *rc= RKC(i);
arith_op_continue( luai_numadd, try_addint, luai_vectadd );
Protect(Arith(L, ra, rb, rc, TM_ADD)); \
continue;
}
- case OP_SUB: {
+ OPCODE_TARGET(SUB) {
TValue *rb = RKB(i), *rc= RKC(i);
arith_op_continue( luai_numsub, try_subint, luai_vectsub );
Protect(Arith(L, ra, rb, rc, TM_SUB));
continue;
}
- case OP_MUL: {
+ OPCODE_TARGET(MUL) {
TValue *rb = RKB(i), *rc= RKC(i);
arith_op_continue(luai_nummul, try_mulint, luai_vectmul);
Protect(Arith(L, ra, rb, rc, TM_MUL));
continue;
}
- case OP_DIV: {
+ OPCODE_TARGET(DIV) {
TValue *rb = RKB(i), *rc= RKC(i);
arith_op_continue(luai_numdiv, try_divint, luai_vectdiv);
Protect(Arith(L, ra, rb, rc, TM_DIV));
continue;
}
- case OP_MOD: {
+ OPCODE_TARGET(MOD) {
TValue *rb = RKB(i), *rc= RKC(i);
arith_op_continue_scalar(luai_nummod, try_modint); /* scalars only */
Protect(Arith(L, ra, rb, rc, TM_MOD));
continue;
}
- case OP_POW: {
+ OPCODE_TARGET(POW) {
TValue *rb = RKB(i), *rc= RKC(i);
arith_op_continue(luai_numpow, try_powint, luai_vectpow);
Protect(Arith(L, ra, rb, rc, TM_POW));
continue;
}
- case OP_UNM: {
+ OPCODE_TARGET(UNM) {
TValue *rb = RB(i);
arith_op1_continue(luai_numunm, try_unmint, luai_vectunm);
Protect(Arith(L, ra, rb, rb, TM_UNM));
continue;
}
- case OP_NOT: {
+ OPCODE_TARGET(NOT) {
int res = l_isfalse(RB(i)); /* next assignment may change this value */
setbvalue(ra, res);
continue;
}
- case OP_LEN: {
+ OPCODE_TARGET(LEN) {
const TValue *rb = RB(i);
switch (ttype(rb)) {
case LUA_TTABLE: {
@@ -733,18 +787,18 @@ void luaV_execute (lua_State *L, int nex
}
continue;
}
- case OP_CONCAT: {
+ OPCODE_TARGET(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: {
+ OPCODE_TARGET(JMP) {
dojump(L, pc, GETARG_sBx(i));
continue;
}
- case OP_EQ: {
+ OPCODE_TARGET(EQ) {
TValue *rb = RKB(i);
TValue *rc = RKC(i);
Protect(
@@ -754,7 +808,7 @@ void luaV_execute (lua_State *L, int nex
pc++;
continue;
}
- case OP_LT: {
+ OPCODE_TARGET(LT) {
Protect(
if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))
dojump(L, pc, GETARG_sBx(*pc));
@@ -762,7 +816,7 @@ void luaV_execute (lua_State *L, int nex
pc++;
continue;
}
- case OP_LE: {
+ OPCODE_TARGET(LE) {
Protect(
if (lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))
dojump(L, pc, GETARG_sBx(*pc));
@@ -770,13 +824,13 @@ void luaV_execute (lua_State *L, int nex
pc++;
continue;
}
- case OP_TEST: {
+ OPCODE_TARGET(TEST) {
if (l_isfalse(ra) != GETARG_C(i))
dojump(L, pc, GETARG_sBx(*pc));
pc++;
continue;
}
- case OP_TESTSET: {
+ OPCODE_TARGET(TESTSET) {
TValue *rb = RB(i);
if (l_isfalse(rb) != GETARG_C(i)) {
setobjs2s(L, ra, rb);
@@ -785,7 +839,7 @@ void luaV_execute (lua_State *L, int nex
pc++;
continue;
}
- case OP_CALL: {
+ OPCODE_TARGET(CALL) {
int b = GETARG_B(i);
int nresults = GETARG_C(i) - 1;
if (b != 0) L->top = ra+b; /* else previous instruction set top */
@@ -806,7 +860,7 @@ void luaV_execute (lua_State *L, int nex
}
}
}
- case OP_TAILCALL: {
+ OPCODE_TARGET(TAILCALL) {
int b = GETARG_B(i);
if (b != 0) L->top = ra+b; /* else previous instruction set top */
L->savedpc = pc;
@@ -838,7 +892,7 @@ void luaV_execute (lua_State *L, int nex
}
}
}
- case OP_RETURN: {
+ OPCODE_TARGET(RETURN) {
int b = GETARG_B(i);
if (b != 0) L->top = ra+b-1;
if (L->openupval) luaF_close(L, base);
@@ -853,7 +907,7 @@ void luaV_execute (lua_State *L, int nex
goto reentry;
}
}
- case OP_FORLOOP: {
+ OPCODE_TARGET(FORLOOP) {
/* If start,step and limit are all integers, we don't need to check
* against overflow in the looping.
*/
@@ -881,7 +935,7 @@ void luaV_execute (lua_State *L, int nex
}
continue;
}
- case OP_FORPREP: {
+ OPCODE_TARGET(FORPREP) {
const TValue *init = ra;
const TValue *plimit = ra+1;
const TValue *pstep = ra+2;
@@ -904,7 +958,7 @@ void luaV_execute (lua_State *L, int nex
dojump(L, pc, GETARG_sBx(i));
continue;
}
- case OP_TFORLOOP: {
+ OPCODE_TARGET(TFORLOOP) {
StkId cb = ra + 3; /* call base */
setobjs2s(L, cb+2, ra+2);
setobjs2s(L, cb+1, ra+1);
@@ -920,7 +974,7 @@ void luaV_execute (lua_State *L, int nex
pc++;
continue;
}
- case OP_SETLIST: {
+ OPCODE_TARGET(SETLIST) {
int n = GETARG_B(i);
int c = GETARG_C(i);
int last;
@@ -942,11 +996,11 @@ void luaV_execute (lua_State *L, int nex
}
continue;
}
- case OP_CLOSE: {
+ OPCODE_TARGET(CLOSE) {
luaF_close(L, ra);
continue;
}
- case OP_CLOSURE: {
+ OPCODE_TARGET(CLOSURE) {
Proto *p;
Closure *ncl;
int nup, j;
@@ -966,7 +1020,7 @@ void luaV_execute (lua_State *L, int nex
Protect(luaC_checkGC(L));
continue;
}
- case OP_VARARG: {
+ OPCODE_TARGET(VARARG) {
int b = GETARG_B(i) - 1;
int j;
CallInfo *ci = L->ci;