diff -urN lua-5.1/src/luaconf.h lua-5.1.patched/src/luaconf.h
--- lua-5.1/src/luaconf.h	2006-02-10 18:44:06.000000000 +0100
+++ lua-5.1.patched/src/luaconf.h	2006-05-31 12:18:39.000000000 +0200
@@ -730,7 +730,12 @@
 ** without modifying the main part of the file.
 */
 
-
+#if defined(__GNUC__) && !(defined(__i386) || defined (_M_IX86) || defined(__i386__))
+#  define LUA_DIRECT_THREADED
+#  if !(defined(__sparc__) || defined(__powerpc__))
+#    warning using direct threaded might not be an improvment
+#  endif
+#endif
 
 #endif
 
diff -urN lua-5.1/src/lvm.c lua-5.1.patched/src/lvm.c
--- lua-5.1/src/lvm.c	2006-01-23 20:51:43.000000000 +0100
+++ lua-5.1.patched/src/lvm.c	2006-05-30 17:50:33.000000000 +0200
@@ -369,12 +369,80 @@
       }
 
 
+#ifdef LUA_DIRECT_THREADED
+# define SWITCH(e) goto *jumptab[e];
+# define CASE
+# define BREAK    {\
+                     const Instruction i = *pc++;\
+                     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));\
+                     goto *jumptab[GET_OPCODE(i)];\
+                  }
+#else
+# define SWITCH(e) switch(e)
+# define CASE      case
+# define BREAK     continue
+#endif
+
 
 void luaV_execute (lua_State *L, int nexeccalls) {
   LClosure *cl;
   StkId base;
   TValue *k;
   const Instruction *pc;
+#ifdef LUA_DIRECT_THREADED
+  static void* jumptab[] = {
+&&OP_MOVE,
+&&OP_LOADK,
+&&OP_LOADBOOL,
+&&OP_LOADNIL,
+&&OP_GETUPVAL,
+&&OP_GETGLOBAL,
+&&OP_GETTABLE,
+&&OP_SETGLOBAL,
+&&OP_SETUPVAL,
+&&OP_SETTABLE,
+&&OP_NEWTABLE,
+&&OP_SELF,
+&&OP_ADD,
+&&OP_SUB,
+&&OP_MUL,
+&&OP_DIV,
+&&OP_MOD,
+&&OP_POW,
+&&OP_UNM,
+&&OP_NOT,
+&&OP_LEN,
+&&OP_CONCAT,
+&&OP_JMP,
+&&OP_EQ,
+&&OP_LT,
+&&OP_LE,
+&&OP_TEST,
+&&OP_TESTSET,
+&&OP_CALL,
+&&OP_TAILCALL,
+&&OP_RETURN,
+&&OP_FORLOOP,
+&&OP_FORPREP,
+&&OP_TFORLOOP,
+&&OP_SETLIST,
+&&OP_CLOSE,
+&&OP_CLOSURE,
+&&OP_VARARG };
+#endif
  reentry:  /* entry point */
   pc = L->savedpc;
   cl = &clvalue(L->ci->func)->l;
@@ -398,99 +466,99 @@
     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: {
+    SWITCH (GET_OPCODE(i)) {
+      CASE OP_MOVE: {
         setobjs2s(L, ra, RB(i));
-        continue;
+        BREAK;
       }
-      case OP_LOADK: {
+      CASE OP_LOADK: {
         setobj2s(L, ra, KBx(i));
-        continue;
+        BREAK;
       }
-      case OP_LOADBOOL: {
+      CASE OP_LOADBOOL: {
         setbvalue(ra, GETARG_B(i));
         if (GETARG_C(i)) pc++;  /* skip next instruction (if C) */
-        continue;
+        BREAK;
       }
-      case OP_LOADNIL: {
+      CASE OP_LOADNIL: {
         TValue *rb = RB(i);
         do {
           setnilvalue(rb--);
         } while (rb >= ra);
-        continue;
+        BREAK;
       }
-      case OP_GETUPVAL: {
+      CASE OP_GETUPVAL: {
         int b = GETARG_B(i);
         setobj2s(L, ra, cl->upvals[b]->v);
-        continue;
+        BREAK;
       }
-      case OP_GETGLOBAL: {
+      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;
+        BREAK;
       }
-      case OP_GETTABLE: {
+      CASE OP_GETTABLE: {
         Protect(luaV_gettable(L, RB(i), RKC(i), ra));
-        continue;
+        BREAK;
       }
-      case OP_SETGLOBAL: {
+      CASE OP_SETGLOBAL: {
         TValue g;
         sethvalue(L, &g, cl->env);
         lua_assert(ttisstring(KBx(i)));
         Protect(luaV_settable(L, &g, KBx(i), ra));
-        continue;
+        BREAK;
       }
-      case OP_SETUPVAL: {
+      CASE OP_SETUPVAL: {
         UpVal *uv = cl->upvals[GETARG_B(i)];
         setobj(L, uv->v, ra);
         luaC_barrier(L, uv, ra);
-        continue;
+        BREAK;
       }
-      case OP_SETTABLE: {
+      CASE OP_SETTABLE: {
         Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
-        continue;
+        BREAK;
       }
-      case OP_NEWTABLE: {
+      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;
+        BREAK;
       }
-      case OP_SELF: {
+      CASE OP_SELF: {
         StkId rb = RB(i);
         setobjs2s(L, ra+1, rb);
         Protect(luaV_gettable(L, rb, RKC(i), ra));
-        continue;
+        BREAK;
       }
-      case OP_ADD: {
+      CASE OP_ADD: {
         arith_op(luai_numadd, TM_ADD);
-        continue;
+        BREAK;
       }
-      case OP_SUB: {
+      CASE OP_SUB: {
         arith_op(luai_numsub, TM_SUB);
-        continue;
+        BREAK;
       }
-      case OP_MUL: {
+      CASE OP_MUL: {
         arith_op(luai_nummul, TM_MUL);
-        continue;
+        BREAK;
       }
-      case OP_DIV: {
+      CASE OP_DIV: {
         arith_op(luai_numdiv, TM_DIV);
-        continue;
+        BREAK;
       }
-      case OP_MOD: {
+      CASE OP_MOD: {
         arith_op(luai_nummod, TM_MOD);
-        continue;
+        BREAK;
       }
-      case OP_POW: {
+      CASE OP_POW: {
         arith_op(luai_numpow, TM_POW);
-        continue;
+        BREAK;
       }
-      case OP_UNM: {
+      CASE OP_UNM: {
         TValue *rb = RB(i);
         if (ttisnumber(rb)) {
           lua_Number nb = nvalue(rb);
@@ -499,14 +567,14 @@
         else {
           Protect(Arith(L, ra, rb, rb, TM_UNM));
         }
-        continue;
+        BREAK;
       }
-      case OP_NOT: {
+      CASE OP_NOT: {
         int res = l_isfalse(RB(i));  /* next assignment may change this value */
         setbvalue(ra, res);
-        continue;
+        BREAK;
       }
-      case OP_LEN: {
+      CASE OP_LEN: {
         const TValue *rb = RB(i);
         switch (ttype(rb)) {
           case LUA_TTABLE: {
@@ -524,20 +592,20 @@
             )
           }
         }
-        continue;
+        BREAK;
       }
-      case OP_CONCAT: {
+      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;
+        BREAK;
       }
-      case OP_JMP: {
+      CASE OP_JMP: {
         dojump(L, pc, GETARG_sBx(i));
-        continue;
+        BREAK;
       }
-      case OP_EQ: {
+      CASE OP_EQ: {
         TValue *rb = RKB(i);
         TValue *rc = RKC(i);
         Protect(
@@ -545,40 +613,40 @@
             dojump(L, pc, GETARG_sBx(*pc));
         )
         pc++;
-        continue;
+        BREAK;
       }
-      case OP_LT: {
+      CASE OP_LT: {
         Protect(
           if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))
             dojump(L, pc, GETARG_sBx(*pc));
         )
         pc++;
-        continue;
+        BREAK;
       }
-      case OP_LE: {
+      CASE OP_LE: {
         Protect(
           if (lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))
             dojump(L, pc, GETARG_sBx(*pc));
         )
         pc++;
-        continue;
+        BREAK;
       }
-      case OP_TEST: {
+      CASE OP_TEST: {
         if (l_isfalse(ra) != GETARG_C(i))
           dojump(L, pc, GETARG_sBx(*pc));
         pc++;
-        continue;
+        BREAK;
       }
-      case OP_TESTSET: {
+      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;
+        BREAK;
       }
-      case OP_CALL: {
+      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 */
@@ -592,14 +660,14 @@
             /* it was a C function (`precall' called it); adjust results */
             if (nresults >= 0) L->top = L->ci->top;
             base = L->base;
-            continue;
+            BREAK;
           }
           default: {
             return;  /* yield */
           }
         }
       }
-      case OP_TAILCALL: {
+      CASE OP_TAILCALL: {
         int b = GETARG_B(i);
         if (b != 0) L->top = ra+b;  /* else previous instruction set top */
         L->savedpc = pc;
@@ -624,14 +692,14 @@
           }
           case PCRC: {  /* it was a C function (`precall' called it) */
             base = L->base;
-            continue;
+            BREAK;
           }
           default: {
             return;  /* yield */
           }
         }
       }
-      case OP_RETURN: {
+      CASE OP_RETURN: {
         int b = GETARG_B(i);
         if (b != 0) L->top = ra+b-1;
         if (L->openupval) luaF_close(L, base);
@@ -646,7 +714,7 @@
           goto reentry;
         }
       }
-      case OP_FORLOOP: {
+      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);
@@ -656,9 +724,9 @@
           setnvalue(ra, idx);  /* update internal index... */
           setnvalue(ra+3, idx);  /* ...and external index */
         }
-        continue;
+        BREAK;
       }
-      case OP_FORPREP: {
+      CASE OP_FORPREP: {
         const TValue *init = ra;
         const TValue *plimit = ra+1;
         const TValue *pstep = ra+2;
@@ -671,9 +739,9 @@
           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;
+        BREAK;
       }
-      case OP_TFORLOOP: {
+      CASE OP_TFORLOOP: {
         StkId cb = ra + 3;  /* call base */
         setobjs2s(L, cb+2, ra+2);
         setobjs2s(L, cb+1, ra+1);
@@ -687,9 +755,9 @@
           dojump(L, pc, GETARG_sBx(*pc));  /* jump back */
         }
         pc++;
-        continue;
+        BREAK;
       }
-      case OP_SETLIST: {
+      CASE OP_SETLIST: {
         int n = GETARG_B(i);
         int c = GETARG_C(i);
         int last;
@@ -709,13 +777,13 @@
           setobj2t(L, luaH_setnum(L, h, last--), val);
           luaC_barriert(L, h, val);
         }
-        continue;
+        BREAK;
       }
-      case OP_CLOSE: {
+      CASE OP_CLOSE: {
         luaF_close(L, ra);
-        continue;
+        BREAK;
       }
-      case OP_CLOSURE: {
+      CASE OP_CLOSURE: {
         Proto *p;
         Closure *ncl;
         int nup, j;
@@ -733,9 +801,9 @@
         }
         setclvalue(L, ra, ncl);
         Protect(luaC_checkGC(L));
-        continue;
+        BREAK;
       }
-      case OP_VARARG: {
+      CASE OP_VARARG: {
         int b = GETARG_B(i) - 1;
         int j;
         CallInfo *ci = L->ci;
@@ -754,7 +822,7 @@
             setnilvalue(ra + j);
           }
         }
-        continue;
+        BREAK;
       }
     }
   }