use branch instricts for blua

mostly just for error handling
similar to upstream lua and bluajit
hope this speeds this up a little

src/blua/lauxlib.c

@@ -133,26 +133,26 @@ LUALIB_API void *luaL_checkudata (lua_State *L, int ud, const char *tname) {
 
 
 LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *mes) {
-  if (!lua_checkstack(L, space))
+  if (l_unlikely(!lua_checkstack(L, space)))
     luaL_error(L, "stack overflow (%s)", mes);
 }
 
 
 LUALIB_API void luaL_checktype (lua_State *L, int narg, int t) {
-  if (lua_type(L, narg) != t)
+  if (l_unlikely(lua_type(L, narg) != t))
     tag_error(L, narg, t);
 }
 
 
 LUALIB_API void luaL_checkany (lua_State *L, int narg) {
-  if (lua_type(L, narg) == LUA_TNONE)
+  if (l_unlikely(lua_type(L, narg) == LUA_TNONE))
     luaL_argerror(L, narg, "value expected");
 }
 
 
 LUALIB_API const char *luaL_checklstring (lua_State *L, int narg, size_t *len) {
   const char *s = lua_tolstring(L, narg, len);
-  if (!s) tag_error(L, narg, LUA_TSTRING);
+  if (l_unlikely(!s)) tag_error(L, narg, LUA_TSTRING);
   return s;
 }
 
@@ -170,7 +170,7 @@ LUALIB_API const char *luaL_optlstring (lua_State *L, int narg,
 
 LUALIB_API lua_Number luaL_checknumber (lua_State *L, int narg) {
   lua_Number d = lua_tonumber(L, narg);
-  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
+  if (l_unlikely(d == 0 && !lua_isnumber(L, narg)))  /* avoid extra test when d is not 0 */
     tag_error(L, narg, LUA_TNUMBER);
   return d;
 }

src/blua/lauxlib.h

@@ -102,7 +102,7 @@ LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx,
 */
 
 #define luaL_argcheck(L, cond,numarg,extramsg)	\
-		((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
+		((void)(l_likely(cond) || luaL_argerror(L, (numarg), (extramsg))))
 #define luaL_checkstring(L,n)	(luaL_checklstring(L, (n), NULL))
 #define luaL_optstring(L,n,d)	(luaL_optlstring(L, (n), (d), NULL))
 #define luaL_checkint(L,n)	((int)luaL_checkinteger(L, (n)))

src/blua/lbaselib.c

@@ -106,7 +106,7 @@ static int luaB_setmetatable (lua_State *L) {
   luaL_checktype(L, 1, LUA_TTABLE);
   luaL_argcheck(L, t == LUA_TNIL || t == LUA_TTABLE, 2,
                     "nil or table expected");
-  if (luaL_getmetafield(L, 1, "__metatable"))
+  if (l_unlikely(luaL_getmetafield(L, 1, "__metatable")))
     luaL_error(L, "cannot change a protected metatable");
   lua_settop(L, 2);
   lua_setmetatable(L, 1);
@@ -120,10 +120,10 @@ static void getfunc (lua_State *L, int opt) {
     lua_Debug ar;
     int level = opt ? luaL_optint(L, 1, 1) : luaL_checkint(L, 1);
     luaL_argcheck(L, level >= 0, 1, "level must be non-negative");
-    if (lua_getstack(L, level, &ar) == 0)
+    if (l_unlikely(lua_getstack(L, level, &ar) == 0))
       luaL_argerror(L, 1, "invalid level");
     lua_getinfo(L, "f", &ar);
-    if (lua_isnil(L, -1))
+    if (l_unlikely(lua_isnil(L, -1)))
       luaL_error(L, "no function environment for tail call at level %d",
                     level);
   }
@@ -151,7 +151,7 @@ static int luaB_setfenv (lua_State *L) {
     lua_setfenv(L, -2);
     return 0;
   }
-  else if (lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0)
+  else if (l_unlikely(lua_iscfunction(L, -2) || lua_setfenv(L, -2) == 0))
     luaL_error(L,
           LUA_QL("setfenv") " cannot change environment of given object");
   return 1;
@@ -265,7 +265,7 @@ static int luaB_ipairs (lua_State *L) {
 
 static int luaB_assert (lua_State *L) {
   luaL_checkany(L, 1);
-  if (!lua_toboolean(L, 1))
+  if (l_unlikely(!lua_toboolean(L, 1)))
     return luaL_error(L, "%s", luaL_optstring(L, 2, "assertion failed!"));
   return lua_gettop(L);
 }
@@ -278,7 +278,7 @@ static int luaB_unpack (lua_State *L) {
   e = luaL_opt(L, luaL_checkint, 3, luaL_getn(L, 1));
   if (i > e) return 0;  /* empty range */
   n = e - i + 1;  /* number of elements */
-  if (n <= 0 || !lua_checkstack(L, n))  /* n <= 0 means arith. overflow */
+  if (l_unlikely(n <= 0 || !lua_checkstack(L, n)))  /* n <= 0 means arith. overflow */
     return luaL_error(L, "too many results to unpack");
   lua_rawgeti(L, 1, i);  /* push arg[i] (avoiding overflow problems) */
   while (i++ < e)  /* push arg[i + 1...e] */
@@ -445,9 +445,9 @@ static int luaB_costatus (lua_State *L) {
 
 static int auxresume (lua_State *L, lua_State *co, int narg) {
   int status = costatus(L, co);
-  if (!lua_checkstack(co, narg))
+  if (l_unlikely(!lua_checkstack(co, narg)))
     luaL_error(L, "too many arguments to resume");
-  if (status != CO_SUS) {
+  if (l_unlikely(status != CO_SUS)) {
     lua_pushfstring(L, "cannot resume %s coroutine", statnames[status]);
     return -1;  /* error flag */
   }
@@ -456,7 +456,7 @@ static int auxresume (lua_State *L, lua_State *co, int narg) {
   status = lua_resume(co, narg);
   if (status == 0 || status == LUA_YIELD) {
     int nres = lua_gettop(co);
-    if (!lua_checkstack(L, nres + 1))
+    if (l_unlikely(!lua_checkstack(L, nres + 1)))
       luaL_error(L, "too many results to resume");
     lua_xmove(co, L, nres);  /* move yielded values */
     return nres;

src/blua/ldblib.c

@@ -73,7 +73,7 @@ static int db_getinfo (lua_State *L) {
   }
   else
     return luaL_argerror(L, arg+1, "function or level expected");
-  if (!lua_getinfo(L1, options, &ar))
+  if (l_unlikely(!lua_getinfo(L1, options, &ar)))
     return luaL_argerror(L, arg+2, "invalid option");
   lua_createtable(L, 0, 2);
   if (strchr(options, 'S')) {
@@ -104,7 +104,7 @@ static int db_getlocal (lua_State *L) {
   lua_State *L1 = getthread(L, &arg);
   lua_Debug ar;
   const char *name;
-  if (!lua_getstack(L1, luaL_checkint(L, arg+1), &ar))  /* out of range? */
+  if (l_unlikely(!lua_getstack(L1, luaL_checkint(L, arg+1), &ar)))  /* out of range? */
     return luaL_argerror(L, arg+1, "level out of range");
   name = lua_getlocal(L1, &ar, luaL_checkint(L, arg+2));
   if (name) {

src/blua/ldo.c

@@ -172,7 +172,7 @@ void luaD_reallocCI (lua_State *L, int newsize) {
 
 
 void luaD_growstack (lua_State *L, int n) {
-  if (n <= L->stacksize)  /* double size is enough? */
+  if (l_likely(n <= L->stacksize))  /* double size is enough? */
     luaD_reallocstack(L, 2*L->stacksize);
   else
     luaD_reallocstack(L, L->stacksize + n);
@@ -180,11 +180,11 @@ void luaD_growstack (lua_State *L, int n) {
 
 
 static CallInfo *growCI (lua_State *L) {
-  if (L->size_ci > LUAI_MAXCALLS)  /* overflow while handling overflow? */
+  if (l_unlikely(L->size_ci > LUAI_MAXCALLS))  /* overflow while handling overflow? */
     luaD_throw(L, LUA_ERRERR);
   else {
     luaD_reallocCI(L, 2*L->size_ci);
-    if (L->size_ci > LUAI_MAXCALLS)
+    if (l_unlikely(L->size_ci > LUAI_MAXCALLS))
       luaG_runerror(L, "stack overflow");
   }
   return ++L->ci;
@@ -257,7 +257,7 @@ static StkId tryfuncTM (lua_State *L, StkId func) {
   const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);
   StkId p;
   ptrdiff_t funcr = savestack(L, func);
-  if (!ttisfunction(tm))
+  if (l_unlikely(!ttisfunction(tm)))
     luaG_typeerror(L, func, "call");
   /* Open a hole inside the stack at `func' */
   for (p = L->top; p > func; p--) setobjs2s(L, p, p-1);
@@ -356,7 +356,7 @@ int luaD_poscall (lua_State *L, StkId firstResult) {
   StkId res;
   int wanted, i;
   CallInfo *ci;
-  if (L->hookmask & LUA_MASKRET)
+  if (l_unlikely(L->hookmask) & LUA_MASKRET)
     firstResult = callrethooks(L, firstResult);
   ci = L->ci--;
   res = ci->func;  /* res == final position of 1st result */
@@ -380,7 +380,7 @@ int luaD_poscall (lua_State *L, StkId firstResult) {
 ** function position.
 */
 void luaD_call (lua_State *L, StkId func, int nResults) {
-  if (++L->nCcalls >= LUAI_MAXCCALLS) {
+  if (l_unlikely(++L->nCcalls >= LUAI_MAXCCALLS)) {
     if (L->nCcalls == LUAI_MAXCCALLS)
       luaG_runerror(L, "C stack overflow");
     else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
@@ -430,15 +430,15 @@ static int resume_error (lua_State *L, const char *msg) {
 LUA_API int lua_resume (lua_State *L, int nargs) {
   int status;
   lua_lock(L);
-  if (L->status != LUA_YIELD && (L->status != 0 || L->ci != L->base_ci))
+  if (l_unlikely(L->status != LUA_YIELD && (L->status != 0 || L->ci != L->base_ci)))
       return resume_error(L, "cannot resume non-suspended coroutine");
-  if (L->nCcalls >= LUAI_MAXCCALLS)
+  if (l_unlikely(L->nCcalls >= LUAI_MAXCCALLS))
     return resume_error(L, "C stack overflow");
   luai_userstateresume(L, nargs);
   lua_assert(L->errfunc == 0);
   L->baseCcalls = ++L->nCcalls;
   status = luaD_rawrunprotected(L, resume, L->top - nargs);
-  if (status != 0) {  /* error? */
+  if (l_unlikely(status != 0)) {  /* error? */
     L->status = cast_byte(status);  /* mark thread as `dead' */
     luaD_seterrorobj(L, status, L->top);
     L->ci->top = L->top;
@@ -456,7 +456,7 @@ LUA_API int lua_resume (lua_State *L, int nargs) {
 LUA_API int lua_yield (lua_State *L, int nresults) {
   luai_userstateyield(L, nresults);
   lua_lock(L);
-  if (L->nCcalls > L->baseCcalls)
+  if (l_unlikely(L->nCcalls > L->baseCcalls))
     luaG_runerror(L, "attempt to yield across metamethod/C-call boundary");
   L->base = L->top - nresults;  /* protect stack slots below */
   L->status = LUA_YIELD;
@@ -474,7 +474,7 @@ int luaD_pcall (lua_State *L, Pfunc func, void *u,
   ptrdiff_t old_errfunc = L->errfunc;
   L->errfunc = ef;
   status = luaD_rawrunprotected(L, func, u);
-  if (status != 0) {  /* an error occurred? */
+  if (l_unlikely(status != 0)) {  /* an error occurred? */
     StkId oldtop = restorestack(L, old_top);
     luaF_close(L, oldtop);  /* close eventual pending closures */
     luaD_seterrorobj(L, status, oldtop);
@@ -511,8 +511,8 @@ static void f_parser (lua_State *L, void *ud) {
   tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,
                                                              &p->buff, p->name);
 #else
-  if (c == LUA_SIGNATURE[0])
-		luaG_runerror(L, "invalid format, cannot load bytecode scripts");
+  if (l_unlikely(c == LUA_SIGNATURE[0]))
+      luaG_runerror(L, "invalid format, cannot load bytecode scripts");
   tf = luaY_parser(L, p->z, &p->buff, p->name);
 #endif
   cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));

src/blua/ldo.h

@@ -14,7 +14,7 @@
 
 
 #define luaD_checkstack(L,n)	\
-  if ((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TValue)) \
+  if (l_unlikely((char *)L->stack_last - (char *)L->top <= (n)*(int)sizeof(TValue))) \
     luaD_growstack(L, n); \
   else condhardstacktests(luaD_reallocstack(L, L->stacksize - EXTRA_STACK - 1));
 

src/blua/liolib.c

@@ -84,7 +84,7 @@ static int io_type (lua_State *L) {
 
 static FILE *tofile (lua_State *L) {
   FILE **f = tofilep(L);
-  if (*f == NULL)
+  if (l_unlikely(*f == NULL))
     luaL_error(L, "attempt to use a closed file");
   return *f;
 }
@@ -184,8 +184,8 @@ static int io_open (lua_State *L) {
 			break;
 		}
 	}
-	if (strstr(filename, "..") || strchr(filename, ':') || StartsWith(filename, "\\")
-		|| StartsWith(filename, "/") || !pass)
+	if (l_unlikely(strstr(filename, "..") || strchr(filename, ':') || StartsWith(filename, "\\")
+		|| StartsWith(filename, "/") || !pass))
 	{
 		luaL_error(L,"access denied to %s", filename);
 		return pushresult(L,0,filename);
@@ -202,7 +202,7 @@ static int io_open (lua_State *L) {
 	{
 		*splitter = 0;
 		I_mkdir(destFilename, 0755);
-		*splitter = '/'; 
+		*splitter = '/';
 		splitter++;
 
         forward = strchr(splitter, '/');
@@ -226,7 +226,7 @@ static FILE *getiofile (lua_State *L, int findex) {
   FILE *f;
   lua_rawgeti(L, LUA_ENVIRONINDEX, findex);
   f = *(FILE **)lua_touserdata(L, -1);
-  if (f == NULL)
+  if (l_unlikely(f == NULL))
     luaL_error(L, "standard %s file is closed", fnames[findex - 1]);
   return f;
 }
@@ -238,7 +238,7 @@ static int g_iofile (lua_State *L, int f, const char *mode) {
     if (filename) {
       FILE **pf = newfile(L);
       *pf = fopen(filename, mode);
-      if (*pf == NULL)
+      if (l_unlikely(*pf == NULL))
         fileerror(L, 1, filename);
     }
     else {
@@ -290,7 +290,7 @@ static int io_lines (lua_State *L) {
     const char *filename = luaL_checkstring(L, 1);
     FILE **pf = newfile(L);
     *pf = fopen(filename, "r");
-    if (*pf == NULL)
+    if (l_unlikely(*pf == NULL))
       fileerror(L, 1, filename);
     aux_lines(L, lua_gettop(L), 1);
     return 1;
@@ -307,7 +307,7 @@ static int io_lines (lua_State *L) {
 
 static int read_number (lua_State *L, FILE *f) {
   lua_Number d;
-  if (fscanf(f, LUA_NUMBER_SCAN, &d) == 1) {
+  if (l_likely(fscanf(f, LUA_NUMBER_SCAN, &d) == 1)) {
     lua_pushnumber(L, d);
     return 1;
   }
@@ -454,7 +454,7 @@ static int g_write (lua_State *L, FILE *f, int arg) {
     else {
       size_t l;
       const char *s = luaL_checklstring(L, arg, &l);
-	  if (ftell(f) + l > FILELIMIT)
+	  if (l_unlikely(ftell(f) + l > FILELIMIT))
 	  {
 		luaL_error(L,"write limit bypassed in file. Changes have been discarded.");
 		break;
@@ -483,7 +483,7 @@ static int f_seek (lua_State *L) {
   int op = luaL_checkoption(L, 2, "cur", modenames);
   long offset = luaL_optlong(L, 3, 0);
   op = fseek(f, offset, mode[op]);
-  if (op)
+  if (l_unlikely(op))
     return pushresult(L, 0, NULL);  /* error */
   else {
     lua_pushinteger(L, ftell(f));

src/blua/lmem.c

@@ -48,7 +48,7 @@ void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
   void *newblock;
   int newsize;
   if (*size >= limit/2) {  /* cannot double it? */
-    if (*size >= limit)  /* cannot grow even a little? */
+    if (l_unlikely(*size >= limit))  /* cannot grow even a little? */
       luaG_runerror(L, errormsg);
     newsize = limit;  /* still have at least one free place */
   }
@@ -77,7 +77,7 @@ void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
   global_State *g = G(L);
   lua_assert((osize == 0) == (block == NULL));
   block = (*g->frealloc)(g->ud, block, osize, nsize);
-  if (block == NULL && nsize > 0)
+  if (l_unlikely(block == NULL && nsize > 0))
     luaD_throw(L, LUA_ERRMEM);
   lua_assert((nsize == 0) == (block == NULL));
   g->totalbytes = (g->totalbytes - osize) + nsize;

src/blua/lparser.c

@@ -103,7 +103,7 @@ static void checknext (LexState *ls, int c) {
 
 
 static void check_match (LexState *ls, int what, int who, int where) {
-  if (!testnext(ls, what)) {
+  if (l_unlikely(!testnext(ls, what))) {
     if (where == ls->linenumber)
       error_expected(ls, what);
     else {
@@ -275,7 +275,7 @@ static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
 
 
 static void enterlevel (LexState *ls) {
-  if (++ls->L->nCcalls > LUAI_MAXCCALLS)
+  if (l_unlikely(++ls->L->nCcalls > LUAI_MAXCCALLS))
 	luaX_lexerror(ls, "chunk has too many syntax levels", 0);
 }
 
@@ -643,7 +643,7 @@ static void funcargs (LexState *ls, expdesc *f) {
   int line = ls->linenumber;
   switch (ls->t.token) {
     case '(': {  /* funcargs -> `(' [ explist1 ] `)' */
-      if (line != ls->lastline)
+      if (l_unlikely(line != ls->lastline))
         luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
       luaX_next(ls);
       if (ls->t.token == ')')  /* arg list is empty? */
@@ -712,7 +712,7 @@ static void prefixexp (LexState *ls, expdesc *v) {
     case '$': {
       lua_Number i = ls->t.seminfo.r;
       if (i == 0) i = ls->fs->nrhs;
-      if (i <= 0 || i > ls->fs->nlhs)
+      if (l_unlikely(i <= 0 || i > ls->fs->nlhs))
         luaX_syntaxerror(ls, "pseudo-variable out of range or not in assignment");
       else {
         expdesc_list *lhs = ls->fs->lhs;
@@ -1105,7 +1105,7 @@ static void breakstat (LexState *ls, lua_Number n) {
     upval |= bl->upval;
     bl = bl->previous;
   }
-  if (!bl)
+  if (l_unlikely(!bl))
     luaX_syntaxerror(ls, "no loop to break");
   if (upval)
     luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
@@ -1124,7 +1124,7 @@ static void continuestat (LexState *ls) {
     //upval |= bl->upval;     // AK: ADDITION (would this fix forbody probs?)
     bl = bl->previous;
   }
-  if (!bl)
+  if (l_unlikely(!bl))
     luaX_syntaxerror(ls, "no loop to continue");
 
   //if (upval)    //AK: experimental

src/blua/lstring.c

@@ -83,7 +83,7 @@ TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
        o != NULL;
        o = o->gch.next) {
     TString *ts = rawgco2ts(o);
-    if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0)) {
+    if (l_unlikely(ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0))) {
       /* string may be dead */
       if (isdead(G(L), o)) changewhite(o);
       return ts;
@@ -95,7 +95,7 @@ TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
 
 Udata *luaS_newudata (lua_State *L, size_t s, Table *e) {
   Udata *u;
-  if (s > MAX_SIZET - sizeof(Udata))
+  if (l_unlikely(s > MAX_SIZET - sizeof(Udata)))
     luaM_toobig(L);
   u = cast(Udata *, luaM_malloc(L, s + sizeof(Udata)));
   u->uv.marked = luaC_white(G(L));  /* is not finalized */

src/blua/lstrlib.c

@@ -113,7 +113,7 @@ static int str_byte (lua_State *L) {
   if ((size_t)pose > l) pose = l;
   if (posi > pose) return 0;  /* empty interval; return no values */
   n = (int)(pose -  posi + 1);
-  if (posi + n <= pose)  /* overflow? */
+  if (l_unlikely(posi + n <= pose))  /* overflow? */
     luaL_error(L, "string slice too long");
   luaL_checkstack(L, n, "string slice too long");
   for (i=0; i<n; i++)
@@ -187,7 +187,7 @@ typedef struct MatchState {
 
 static int check_capture (MatchState *ms, int l) {
   l -= '1';
-  if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
+  if (l_unlikely(l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED))
     return luaL_error(ms->L, "invalid capture index");
   return l;
 }
@@ -204,14 +204,14 @@ static int capture_to_close (MatchState *ms) {
 static const char *classend (MatchState *ms, const char *p) {
   switch (*p++) {
     case L_ESC: {
-      if (*p == '\0')
+      if (l_unlikely(*p == '\0'))
         luaL_error(ms->L, "malformed pattern (ends with " LUA_QL("%%") ")");
       return p+1;
     }
     case '[': {
       if (*p == '^') p++;
       do {  /* look for a `]' */
-        if (*p == '\0')
+        if (l_unlikely(*p == '\0'))
           luaL_error(ms->L, "malformed pattern (missing " LUA_QL("]") ")");
         if (*(p++) == L_ESC && *p != '\0')
           p++;  /* skip escapes (e.g. `%]') */
@@ -282,7 +282,7 @@ static const char *match (MatchState *ms, const char *s, const char *p);
 
 static const char *matchbalance (MatchState *ms, const char *s,
                                    const char *p) {
-  if (*p == 0 || *(p+1) == 0)
+  if (l_unlikely(*p == 0 || *(p+1) == 0))
     luaL_error(ms->L, "unbalanced pattern");
   if (*s != *p) return NULL;
   else {
@@ -332,7 +332,8 @@ static const char *start_capture (MatchState *ms, const char *s,
                                     const char *p, int what) {
   const char *res;
   int level = ms->level;
-  if (level >= LUA_MAXCAPTURES) luaL_error(ms->L, "too many captures");
+  if (l_unlikely(level >= LUA_MAXCAPTURES))
+    luaL_error(ms->L, "too many captures");
   ms->capture[level].init = s;
   ms->capture[level].len = what;
   ms->level = level+1;
@@ -386,7 +387,7 @@ static const char *match (MatchState *ms, const char *s, const char *p) {
         case 'f': {  /* frontier? */
           const char *ep; char previous;
           p += 2;
-          if (*p != '[')
+          if (l_unlikely(*p != '['))
             luaL_error(ms->L, "missing " LUA_QL("[") " after "
                                LUA_QL("%%f") " in pattern");
           ep = classend(ms, p);  /* points to what is next */
@@ -468,14 +469,15 @@ static const char *lmemfind (const char *s1, size_t l1,
 static void push_onecapture (MatchState *ms, int i, const char *s,
                                                     const char *e) {
   if (i >= ms->level) {
-    if (i == 0)  /* ms->level == 0, too */
+    if (l_likely(i == 0))  /* ms->level == 0, too */
       lua_pushlstring(ms->L, s, e - s);  /* add whole match */
     else
       luaL_error(ms->L, "invalid capture index");
   }
   else {
     ptrdiff_t l = ms->capture[i].len;
-    if (l == CAP_UNFINISHED) luaL_error(ms->L, "unfinished capture");
+    if (l_unlikely(l == CAP_UNFINISHED))
+      luaL_error(ms->L, "unfinished capture");
     if (l == CAP_POSITION)
       lua_pushinteger(ms->L, ms->capture[i].init - ms->src_init + 1);
     else
@@ -637,7 +639,7 @@ static void add_value (MatchState *ms, luaL_Buffer *b, const char *s,
     lua_pop(L, 1);
     lua_pushlstring(L, s, e - s);  /* keep original text */
   }
-  else if (!lua_isstring(L, -1))
+  else if (l_unlikely(!lua_isstring(L, -1)))
     luaL_error(L, "invalid replacement value (a %s)", luaL_typename(L, -1));
   luaL_addvalue(b);  /* add result to accumulator */
 }
@@ -727,7 +729,7 @@ static void addquoted (lua_State *L, luaL_Buffer *b, int arg) {
 static const char *scanformat (lua_State *L, const char *strfrmt, char *form) {
   const char *p = strfrmt;
   while (*p != '\0' && strchr(FLAGS, *p) != NULL) p++;  /* skip flags */
-  if ((size_t)(p - strfrmt) >= sizeof(FLAGS))
+  if (l_unlikely((size_t)(p - strfrmt) >= sizeof(FLAGS)))
     luaL_error(L, "invalid format (repeated flags)");
   if (isdigit(uchar(*p))) p++;  /* skip width */
   if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */
@@ -736,7 +738,7 @@ static const char *scanformat (lua_State *L, const char *strfrmt, char *form) {
     if (isdigit(uchar(*p))) p++;  /* skip precision */
     if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */
   }
-  if (isdigit(uchar(*p)))
+  if (l_unlikely(isdigit(uchar(*p))))
     luaL_error(L, "invalid format (width or precision too long)");
   *(form++) = '%';
   strncpy(form, strfrmt, p - strfrmt + 1);

src/blua/ltable.c

@@ -278,7 +278,7 @@ static void setnodevector (lua_State *L, Table *t, int size) {
   else {
     int i;
     lsize = ceillog2(size);
-    if (lsize > MAXBITS)
+    if (l_unlikely(lsize > MAXBITS))
       luaG_runerror(L, "table overflow");
     size = twoto(lsize);
     t->node = luaM_newvector(L, size, Node);
@@ -498,8 +498,9 @@ TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
   if (p != luaO_nilobject)
     return cast(TValue *, p);
   else {
-    if (ttisnil(key)) luaG_runerror(L, "table index is nil");
-    else if (ttisnumber(key) && luai_numisnan(nvalue(key)))
+    if (l_unlikely(ttisnil(key)))
+      luaG_runerror(L, "table index is nil");
+    else if (l_unlikely(ttisnumber(key) && luai_numisnan(nvalue(key))))
       luaG_runerror(L, "table index is NaN");
     return newkey(L, t, key);
   }

src/blua/ltablib.c

@@ -134,7 +134,7 @@ static int tremove (lua_State *L) {
 
 static void addfield (lua_State *L, luaL_Buffer *b, int i) {
   lua_rawgeti(L, 1, i);
-  if (!lua_isstring(L, -1))
+  if (l_unlikely(!lua_isstring(L, -1)))
     luaL_error(L, "invalid value (%s) at index %d in table for "
                   LUA_QL("concat"), luaL_typename(L, -1), i);
   luaL_addvalue(b);
@@ -224,12 +224,14 @@ static void auxsort (lua_State *L, int l, int u) {
     for (;;) {  /* invariant: a[l..i] <= P <= a[j..u] */
       /* repeat ++i until a[i] >= P */
       while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) {
-        if (i>u) luaL_error(L, "invalid order function for sorting");
+        if (l_unlikely(i>u))
+          luaL_error(L, "invalid order function for sorting");
         lua_pop(L, 1);  /* remove a[i] */
       }
       /* repeat --j until a[j] <= P */
       while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) {
-        if (j<l) luaL_error(L, "invalid order function for sorting");
+        if (l_unlikely(j<l))
+          luaL_error(L, "invalid order function for sorting");
         lua_pop(L, 1);  /* remove a[j] */
       }
       if (j<i) {

src/blua/luaconf.h

@@ -773,6 +773,23 @@ union luai_Cast { double l_d; long l_l; };
 
 /* =================================================================== */
 
+/*
+ * * macros to improve jump prediction, used mostly for error handling
+ ** and debug facilities.
+ */
+#if !defined(l_likely)
+
+#include <stdio.h>
+#if defined(__GNUC__)
+#define l_likely(x)	(__builtin_expect(((x) != 0), 1))
+#define l_unlikely(x)	(__builtin_expect(((x) != 0), 0))
+#else
+#define l_likely(x)	(x)
+#define l_unlikely(x)	(x)
+#endif
+
+#endif
+
 /*
 ** Local configuration. You can use this space to add your redefinitions
 ** without modifying the main part of the file.

src/blua/lvm.c

@@ -119,7 +119,7 @@ void luaV_gettable (lua_State *L, TValue *t, TValue *key, StkId val) {
       }
       /* else will try the tag method */
     }
-    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))
+    else if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX))))
       luaG_typeerror(L, t, "index");
     if (ttisfunction(tm)) {
       callTMres(L, val, tm, t, key);
@@ -147,7 +147,7 @@ void luaV_settable (lua_State *L, TValue *t, TValue *key, StkId val) {
       }
       /* else will try the tag method */
     }
-    else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
+    else if (l_unlikely(ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))))
       luaG_typeerror(L, t, "index");
     if (ttisfunction(tm)) {
       callTM(L, tm, t, key, val);
@@ -293,7 +293,8 @@ void luaV_concat (lua_State *L, int total, int last) {
       /* collect total length */
       for (n = 1; n < total && tostring(L, top-n-1); n++) {
         size_t l = tsvalue(top-n-1)->len;
-        if (l >= MAX_SIZET - tl) luaG_runerror(L, "string length overflow");
+        if (l_unlikely(l >= MAX_SIZET - tl))
+          luaG_runerror(L, "string length overflow");
         tl += l;
       }
       buffer = luaZ_openspace(L, &G(L)->buff, tl);
@@ -322,8 +323,8 @@ static void Arith (lua_State *L, StkId ra, TValue *rb,
       case TM_ADD: setnvalue(ra, luai_numadd(nb, nc)); break;
       case TM_SUB: setnvalue(ra, luai_numsub(nb, nc)); break;
       case TM_MUL: setnvalue(ra, luai_nummul(nb, nc)); break;
-      case TM_DIV: if (nc == 0) { luaG_runerror(L, "divide by zero error"); } else setnvalue(ra, luai_numdiv(nb, nc)); break;
-      case TM_MOD: if (nc == 0) { luaG_runerror(L, "modulo by zero error"); } else setnvalue(ra, luai_nummod(nb, nc)); break;
+      case TM_DIV: if (l_unlikely(nc == 0)) { luaG_runerror(L, "divide by zero error"); } else setnvalue(ra, luai_numdiv(nb, nc)); break;
+      case TM_MOD: if (l_unlikely(nc == 0)) { luaG_runerror(L, "modulo by zero error"); } else setnvalue(ra, luai_nummod(nb, nc)); break;
       case TM_POW: setnvalue(ra, luai_numpow(nb, nc)); break;
       case TM_UNM: setnvalue(ra, luai_numunm(nb)); break;
       case TM_AND: setnvalue(ra, luai_numand(nb, nc)); break;
@@ -491,7 +492,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         TValue *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
           lua_Number nb = nvalue(rb), nc = nvalue(rc);
-          if (nc == 0) {
+          if (l_unlikely(nc == 0)) {
             luaG_runerror(L, "divide by zero error");
           }
           else
@@ -506,7 +507,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         TValue *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
           lua_Number nb = nvalue(rb), nc = nvalue(rc);
-          if (nc == 0) {
+          if (l_unlikely(nc == 0)) {
             luaG_runerror(L, "modulo by zero error");
           }
           else
@@ -580,7 +581,7 @@ void luaV_execute (lua_State *L, int nexeccalls) {
           }
           default: {  /* try metamethod */
             Protect(
-              if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN))
+              if (l_unlikely(!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN)))
                 luaG_typeerror(L, rb, "get length of");
             )
           }
@@ -724,11 +725,11 @@ void luaV_execute (lua_State *L, int nexeccalls) {
         const TValue *plimit = ra+1;
         const TValue *pstep = ra+2;
         L->savedpc = pc;  /* next steps may throw errors */
-        if (!tonumber(init, ra))
+        if (l_unlikely(!tonumber(init, ra)))
           luaG_runerror(L, LUA_QL("for") " initial value must be a number");
-        else if (!tonumber(plimit, ra+1))
+        else if (l_unlikely(!tonumber(plimit, ra+1)))
           luaG_runerror(L, LUA_QL("for") " limit must be a number");
-        else if (!tonumber(pstep, ra+2))
+        else if (l_unlikely(!tonumber(pstep, ra+2)))
           luaG_runerror(L, LUA_QL("for") " step must be a number");
         if (ra && pstep)
           setnvalue(ra, luai_numsub(nvalue(ra), nvalue(pstep)));