LLVMFuzzerTestOneInput: 145| 258|LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 146| 258| lua_State *L = luaL_newstate(); 147| 258| if (L == NULL) { ------------------ | Branch (147:9): [True: 0, False: 258] ------------------ 148| 0| return 0; 149| 0| } 150| 258| dochunk(L, luaL_loadbufferx(L, data, size, "test", "t")); 151| | 152| 258| lua_close(L); 153| 258| return 0; 154| 258|} fuzz_lua.c:dochunk: 134| 258|static int dochunk (lua_State *L, int status) { 135| 258| if (status == LUA_OK) status = docall(L, 0, 0); ------------------ | | 49| 258|#define LUA_OK 0 ------------------ | Branch (135:7): [True: 40, False: 218] ------------------ 136| 258| return report(L, status); 137| 258|} fuzz_lua.c:docall: 120| 40|static int docall (lua_State *L, int narg, int nres) { 121| 40| int status; 122| 40| int base = lua_gettop(L) - narg; /* function index */ 123| 40| lua_pushcfunction(L, msghandler); /* push message handler */ ------------------ | | 381| 40|#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0) ------------------ 124| 40| lua_insert(L, base); /* put it under function and args */ ------------------ | | 400| 40|#define lua_insert(L,idx) lua_rotate(L, (idx), 1) ------------------ 125| 40| globalL = L; /* to be available to 'laction' */ 126| 40| signal(SIGINT, laction); /* set C-signal handler */ 127| 40| status = lua_pcall(L, narg, nres, base); ------------------ | | 297| 40|#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) ------------------ 128| 40| signal(SIGINT, SIG_DFL); /* reset C-signal handler */ 129| 40| lua_remove(L, base); /* remove message handler from the stack */ ------------------ | | 402| 40|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 375| 40|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 130| 40| return status; 131| 40|} fuzz_lua.c:msghandler: 101| 39|static int msghandler (lua_State *L) { 102| 39| const char *msg = lua_tostring(L, 1); ------------------ | | 397| 39|#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) ------------------ 103| 39| if (msg == NULL) { /* is error object not a string? */ ------------------ | Branch (103:7): [True: 0, False: 39] ------------------ 104| 0| if (luaL_callmeta(L, 1, "__tostring") && /* does it have a metamethod */ ------------------ | Branch (104:9): [True: 0, False: 0] ------------------ 105| 0| lua_type(L, -1) == LUA_TSTRING) /* that produces a string? */ ------------------ | | 69| 0|#define LUA_TSTRING 4 ------------------ | Branch (105:9): [True: 0, False: 0] ------------------ 106| 0| return 1; /* that is the message */ 107| 0| else 108| 0| msg = lua_pushfstring(L, "(error object is a %s value)", 109| 0| luaL_typename(L, 1)); ------------------ | | 142| 0|#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) ------------------ 110| 0| } 111| 39| luaL_traceback(L, L, msg, 1); /* append a standard traceback */ 112| 39| return 1; /* return the traceback */ 113| 39|} fuzz_lua.c:report: 89| 258|static int report (lua_State *L, int status) { 90| 258| if (status != LUA_OK) { ------------------ | | 49| 258|#define LUA_OK 0 ------------------ | Branch (90:7): [True: 257, False: 1] ------------------ 91| 257| const char *msg = lua_tostring(L, -1); ------------------ | | 397| 257|#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) ------------------ 92| 257| l_message(progname, msg); 93| 257| lua_pop(L, 1); /* remove message */ ------------------ | | 375| 257|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 94| 257| } 95| 258| return status; 96| 258|} fuzz_lua.c:l_message: 78| 257|static void l_message (const char *pname, const char *msg) { 79| 257| if (pname) lua_writestringerror("%s: ", pname); ------------------ | | 271| 257| (fprintf(stderr, (s), (p)), fflush(stderr)) ------------------ | Branch (79:7): [True: 257, False: 0] ------------------ 80| 257| lua_writestringerror("%s\n", msg); ------------------ | | 271| 257| (fprintf(stderr, (s), (p)), fflush(stderr)) ------------------ 81| 257|} lua_checkstack: 111| 11|LUA_API int lua_checkstack (lua_State *L, int n) { 112| 11| int res; 113| 11| CallInfo *ci; 114| 11| lua_lock(L); ------------------ | | 264| 11|#define lua_lock(L) ((void) 0) ------------------ 115| 11| ci = L->ci; 116| 11| api_check(L, n >= 0, "negative 'n'"); ------------------ | | 126| 11|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 11|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 117| 11| if (L->stack_last.p - L->top.p > n) /* stack large enough? */ ------------------ | Branch (117:7): [True: 11, False: 0] ------------------ 118| 11| res = 1; /* yes; check is OK */ 119| 0| else /* need to grow stack */ 120| 0| res = luaD_growstack(L, n, 0); 121| 11| if (res && ci->top.p < L->top.p + n) ------------------ | Branch (121:7): [True: 11, False: 0] | Branch (121:14): [True: 0, False: 11] ------------------ 122| 0| ci->top.p = L->top.p + n; /* adjust frame top */ 123| 11| lua_unlock(L); ------------------ | | 265| 11|#define lua_unlock(L) ((void) 0) ------------------ 124| 11| return res; 125| 11|} lua_atpanic: 144| 258|LUA_API lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf) { 145| 258| lua_CFunction old; 146| 258| lua_lock(L); ------------------ | | 264| 258|#define lua_lock(L) ((void) 0) ------------------ 147| 258| old = G(L)->panic; ------------------ | | 335| 258|#define G(L) (L->l_G) ------------------ 148| 258| G(L)->panic = panicf; ------------------ | | 335| 258|#define G(L) (L->l_G) ------------------ 149| 258| lua_unlock(L); ------------------ | | 265| 258|#define lua_unlock(L) ((void) 0) ------------------ 150| 258| return old; 151| 258|} lua_gettop: 176| 100|LUA_API int lua_gettop (lua_State *L) { 177| 100| return cast_int(L->top.p - (L->ci->func.p + 1)); ------------------ | | 141| 100|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 100|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 178| 100|} lua_settop: 181| 550|LUA_API void lua_settop (lua_State *L, int idx) { 182| 550| CallInfo *ci; 183| 550| StkId func, newtop; 184| 550| ptrdiff_t diff; /* difference for new top */ 185| 550| lua_lock(L); ------------------ | | 264| 550|#define lua_lock(L) ((void) 0) ------------------ 186| 550| ci = L->ci; 187| 550| func = ci->func.p; 188| 550| if (idx >= 0) { ------------------ | Branch (188:7): [True: 60, False: 490] ------------------ 189| 60| api_check(L, idx <= ci->top.p - (func + 1), "new top too large"); ------------------ | | 126| 60|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 60|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 60|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 190| 60| diff = ((func + 1) + idx) - L->top.p; 191| 60| for (; diff > 0; diff--) ------------------ | Branch (191:12): [True: 0, False: 60] ------------------ 192| 60| setnilvalue(s2v(L->top.p++)); /* clear new slots */ ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 193| 60| } 194| 490| else { 195| 490| api_check(L, -(idx+1) <= (L->top.p - (func + 1)), "invalid new top"); ------------------ | | 126| 490|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 490|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 490|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 196| 490| diff = idx + 1; /* will "subtract" index (as it is negative) */ 197| 490| } 198| 550| api_check(L, L->tbclist.p < L->top.p, "previous pop of an unclosed slot"); ------------------ | | 126| 550|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 550|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 550|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 199| 550| newtop = L->top.p + diff; 200| 550| if (diff < 0 && L->tbclist.p >= newtop) { ------------------ | Branch (200:7): [True: 539, False: 11] | Branch (200:19): [True: 0, False: 539] ------------------ 201| 0| lua_assert(hastocloseCfunc(ci->nresults)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 202| 0| newtop = luaF_close(L, newtop, CLOSEKTOP, 0); ------------------ | | 47| 0|#define CLOSEKTOP (-1) ------------------ 203| 0| } 204| 550| L->top.p = newtop; /* correct top only after closing any upvalue */ 205| 550| lua_unlock(L); ------------------ | | 265| 550|#define lua_unlock(L) ((void) 0) ------------------ 206| 550|} lua_closeslot: 209| 11|LUA_API void lua_closeslot (lua_State *L, int idx) { 210| 11| StkId level; 211| 11| lua_lock(L); ------------------ | | 264| 11|#define lua_lock(L) ((void) 0) ------------------ 212| 11| level = index2stack(L, idx); 213| 11| api_check(L, hastocloseCfunc(L->ci->nresults) && L->tbclist.p == level, ------------------ | | 126| 11|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 11|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 214| 11| "no variable to close at given level"); 215| 11| level = luaF_close(L, level, CLOSEKTOP, 0); ------------------ | | 47| 11|#define CLOSEKTOP (-1) ------------------ 216| 11| setnilvalue(s2v(level)); ------------------ | | 200| 11|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 11|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 217| 11| lua_unlock(L); ------------------ | | 265| 11|#define lua_unlock(L) ((void) 0) ------------------ 218| 11|} lua_rotate: 241| 141|LUA_API void lua_rotate (lua_State *L, int idx, int n) { 242| 141| StkId p, t, m; 243| 141| lua_lock(L); ------------------ | | 264| 141|#define lua_lock(L) ((void) 0) ------------------ 244| 141| t = L->top.p - 1; /* end of stack segment being rotated */ 245| 141| p = index2stack(L, idx); /* start of segment */ 246| 141| api_check(L, (n >= 0 ? n : -n) <= (t - p + 1), "invalid 'n'"); ------------------ | | 126| 141|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 141|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 141|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 247| 141| m = (n >= 0 ? t - n : p - n - 1); /* end of prefix */ ------------------ | Branch (247:8): [True: 51, False: 90] ------------------ 248| 141| reverse(L, p, m); /* reverse the prefix with length 'n' */ 249| 141| reverse(L, m + 1, t); /* reverse the suffix */ 250| 141| reverse(L, p, t); /* reverse the entire segment */ 251| 141| lua_unlock(L); ------------------ | | 265| 141|#define lua_unlock(L) ((void) 0) ------------------ 252| 141|} lua_pushvalue: 270| 11|LUA_API void lua_pushvalue (lua_State *L, int idx) { 271| 11| lua_lock(L); ------------------ | | 264| 11|#define lua_lock(L) ((void) 0) ------------------ 272| 11| setobj2s(L, L->top.p, index2value(L, idx)); ------------------ | | 131| 11|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 11| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 11| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 11|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 11| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 11| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 11|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 11| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 273| 11| api_incr_top(L); ------------------ | | 16| 11|#define api_incr_top(L) {L->top.p++; \ | | 17| 11| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 11|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 11|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 18| 11| "stack overflow");} ------------------ 274| 11| lua_unlock(L); ------------------ | | 265| 11|#define lua_unlock(L) ((void) 0) ------------------ 275| 11|} lua_type: 284| 60|LUA_API int lua_type (lua_State *L, int idx) { 285| 60| const TValue *o = index2value(L, idx); 286| 60| return (isvalid(L, o) ? ttype(o) : LUA_TNONE); ------------------ | | 46| 60|#define isvalid(L, o) (!ttisnil(o) || o != &G(L)->nilvalue) | | ------------------ | | | | 193| 60|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 120|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 60|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 60|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define isvalid(L, o) (!ttisnil(o) || o != &G(L)->nilvalue) | | ------------------ | | | | 335| 60|#define G(L) (L->l_G) | | ------------------ | | | Branch (46:24): [True: 0, False: 60] | | | Branch (46:39): [True: 60, False: 0] | | ------------------ ------------------ return (isvalid(L, o) ? ttype(o) : LUA_TNONE); ------------------ | | 87| 60|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 60|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ return (isvalid(L, o) ? ttype(o) : LUA_TNONE); ------------------ | | 63| 0|#define LUA_TNONE (-1) ------------------ 287| 60|} lua_tolstring: 405| 417|LUA_API const char *lua_tolstring (lua_State *L, int idx, size_t *len) { 406| 417| TValue *o; 407| 417| lua_lock(L); ------------------ | | 264| 417|#define lua_lock(L) ((void) 0) ------------------ 408| 417| o = index2value(L, idx); 409| 417| if (!ttisstring(o)) { ------------------ | | 363| 417|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 417|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 417|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 417|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (409:7): [True: 0, False: 417] ------------------ 410| 0| if (!cvt2str(o)) { /* not convertible? */ ------------------ | | 17| 0|#define cvt2str(o) ttisnumber(o) | | ------------------ | | | | 326| 0|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (410:9): [True: 0, False: 0] ------------------ 411| 0| if (len != NULL) *len = 0; ------------------ | Branch (411:11): [True: 0, False: 0] ------------------ 412| 0| lua_unlock(L); ------------------ | | 265| 0|#define lua_unlock(L) ((void) 0) ------------------ 413| 0| return NULL; 414| 0| } 415| 0| luaO_tostring(L, o); 416| 0| luaC_checkGC(L); ------------------ | | 172| 0|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 0| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 0|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 0] | | | | ------------------ | | | | 169| 0| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 0|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 417| 0| o = index2value(L, idx); /* previous call may reallocate the stack */ 418| 0| } 419| 417| if (len != NULL) ------------------ | Branch (419:7): [True: 121, False: 296] ------------------ 420| 121| *len = vslen(o); ------------------ | | 413| 121|#define vslen(o) tsslen(tsvalue(o)) | | ------------------ | | | | 410| 121|#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen) | | | | ------------------ | | | | | | 360| 121|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | | | ------------------ | | | | | | | | 42| 121|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (410:20): [True: 121, False: 0] | | | | ------------------ | | ------------------ ------------------ 421| 417| lua_unlock(L); ------------------ | | 265| 417|#define lua_unlock(L) ((void) 0) ------------------ 422| 417| return svalue(o); ------------------ | | 407| 417|#define svalue(o) getstr(tsvalue(o)) | | ------------------ | | | | 403| 417|#define getstr(ts) ((ts)->contents) | | ------------------ ------------------ 423| 417|} lua_touserdata: 456| 44|LUA_API void *lua_touserdata (lua_State *L, int idx) { 457| 44| const TValue *o = index2value(L, idx); 458| 44| return touserdata(o); 459| 44|} lua_pushlstring: 526| 39|LUA_API const char *lua_pushlstring (lua_State *L, const char *s, size_t len) { 527| 39| TString *ts; 528| 39| lua_lock(L); ------------------ | | 264| 39|#define lua_lock(L) ((void) 0) ------------------ 529| 39| ts = (len == 0) ? luaS_new(L, "") : luaS_newlstr(L, s, len); ------------------ | Branch (529:8): [True: 0, False: 39] ------------------ 530| 39| setsvalue2s(L, L->top.p, ts); ------------------ | | 377| 39|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 39| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 39| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 39|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 39|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 39|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 39|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 39| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 39| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 39|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 39| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 531| 39| api_incr_top(L); ------------------ | | 16| 39|#define api_incr_top(L) {L->top.p++; \ | | 17| 39| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 39|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 39|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 39|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 18| 39| "stack overflow");} ------------------ 532| 39| luaC_checkGC(L); ------------------ | | 172| 39|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 39| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 39|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 39] | | | | ------------------ | | | | 169| 39| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 39|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 533| 39| lua_unlock(L); ------------------ | | 265| 39|#define lua_unlock(L) ((void) 0) ------------------ 534| 39| return getstr(ts); ------------------ | | 403| 39|#define getstr(ts) ((ts)->contents) ------------------ 535| 39|} lua_pushstring: 538| 50|LUA_API const char *lua_pushstring (lua_State *L, const char *s) { 539| 50| lua_lock(L); ------------------ | | 264| 50|#define lua_lock(L) ((void) 0) ------------------ 540| 50| if (s == NULL) ------------------ | Branch (540:7): [True: 0, False: 50] ------------------ 541| 50| setnilvalue(s2v(L->top.p)); ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 542| 50| else { 543| 50| TString *ts; 544| 50| ts = luaS_new(L, s); 545| 50| setsvalue2s(L, L->top.p, ts); ------------------ | | 377| 50|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 50| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 50| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 50|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 50|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 50|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 50|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 50| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 50| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 50|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 50| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 546| 50| s = getstr(ts); /* internal copy's address */ ------------------ | | 403| 50|#define getstr(ts) ((ts)->contents) ------------------ 547| 50| } 548| 50| api_incr_top(L); ------------------ | | 16| 50|#define api_incr_top(L) {L->top.p++; \ | | 17| 50| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 50|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 50|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 50|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 18| 50| "stack overflow");} ------------------ 549| 50| luaC_checkGC(L); ------------------ | | 172| 50|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 50| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 50|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 50] | | | | ------------------ | | | | 169| 50| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 50|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 550| 50| lua_unlock(L); ------------------ | | 265| 50|#define lua_unlock(L) ((void) 0) ------------------ 551| 50| return s; 552| 50|} lua_pushfstring: 566| 82|LUA_API const char *lua_pushfstring (lua_State *L, const char *fmt, ...) { 567| 82| const char *ret; 568| 82| va_list argp; 569| 82| lua_lock(L); ------------------ | | 264| 82|#define lua_lock(L) ((void) 0) ------------------ 570| 82| va_start(argp, fmt); 571| 82| ret = luaO_pushvfstring(L, fmt, argp); 572| 82| va_end(argp); 573| 82| luaC_checkGC(L); ------------------ | | 172| 82|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 82| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 82|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 82] | | | | ------------------ | | | | 169| 82| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 82|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 574| 82| lua_unlock(L); ------------------ | | 265| 82|#define lua_unlock(L) ((void) 0) ------------------ 575| 82| return ret; 576| 82|} lua_pushcclosure: 579| 62|LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) { 580| 62| lua_lock(L); ------------------ | | 264| 62|#define lua_lock(L) ((void) 0) ------------------ 581| 62| if (n == 0) { ------------------ | Branch (581:7): [True: 62, False: 0] ------------------ 582| 62| setfvalue(s2v(L->top.p), fn); ------------------ | | 618| 62| { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_VLCF); } | | ------------------ | | | | 72| 62|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_VLCF); } | | ------------------ | | | | 114| 62|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 583| 62| api_incr_top(L); ------------------ | | 16| 62|#define api_incr_top(L) {L->top.p++; \ | | 17| 62| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 62|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 62|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 62|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 18| 62| "stack overflow");} ------------------ 584| 62| } 585| 0| else { 586| 0| CClosure *cl; 587| 0| api_checknelems(L, n); ------------------ | | 33| 0| api_check(L, (n) < (L->top.p - L->ci->func.p), \ | | ------------------ | | | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 0|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 34| 0| "not enough elements in the stack") ------------------ 588| 0| api_check(L, n <= MAXUPVAL, "upvalue index too large"); ------------------ | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 0|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 589| 0| cl = luaF_newCclosure(L, n); 590| 0| cl->f = fn; 591| 0| L->top.p -= n; 592| 0| while (n--) { ------------------ | Branch (592:12): [True: 0, False: 0] ------------------ 593| 0| setobj2n(L, &cl->upvalue[n], s2v(L->top.p + n)); ------------------ | | 135| 0|#define setobj2n setobj | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 594| | /* does not need barrier because closure is white */ 595| 0| lua_assert(iswhite(cl)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 596| 0| } 597| 0| setclCvalue(L, s2v(L->top.p), cl); ------------------ | | 621| 0| { TValue *io = (obj); CClosure *x_ = (x); \ | | 622| 0| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VCCL)); \ | | ------------------ | | | | 72| 0|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VCCL)); \ | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VCCL)); \ | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 623| 0| checkliveness(L,io); } | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 598| 0| api_incr_top(L); ------------------ | | 16| 0|#define api_incr_top(L) {L->top.p++; \ | | 17| 0| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 0|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 18| 0| "stack overflow");} ------------------ 599| 0| luaC_checkGC(L); ------------------ | | 172| 0|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 0| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 0|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 0] | | | | ------------------ | | | | 169| 0| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 0|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 600| 0| } 601| 62| lua_unlock(L); ------------------ | | 265| 62|#define lua_unlock(L) ((void) 0) ------------------ 602| 62|} lua_pushlightuserdata: 616| 39|LUA_API void lua_pushlightuserdata (lua_State *L, void *p) { 617| 39| lua_lock(L); ------------------ | | 264| 39|#define lua_lock(L) ((void) 0) ------------------ 618| 39| setpvalue(s2v(L->top.p), p); ------------------ | | 442| 39| { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_VLIGHTUSERDATA); } | | ------------------ | | | | 72| 39|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_VLIGHTUSERDATA); } | | ------------------ | | | | 114| 39|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 619| 39| api_incr_top(L); ------------------ | | 16| 39|#define api_incr_top(L) {L->top.p++; \ | | 17| 39| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 39|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 39|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 39|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 18| 39| "stack overflow");} ------------------ 620| 39| lua_unlock(L); ------------------ | | 265| 39|#define lua_unlock(L) ((void) 0) ------------------ 621| 39|} lua_getfield: 689| 71|LUA_API int lua_getfield (lua_State *L, int idx, const char *k) { 690| 71| lua_lock(L); ------------------ | | 264| 71|#define lua_lock(L) ((void) 0) ------------------ 691| 71| return auxgetstr(L, index2value(L, idx), k); 692| 71|} lua_createtable: 762| 11|LUA_API void lua_createtable (lua_State *L, int narray, int nrec) { 763| 11| Table *t; 764| 11| lua_lock(L); ------------------ | | 264| 11|#define lua_lock(L) ((void) 0) ------------------ 765| 11| t = luaH_new(L); 766| 11| sethvalue2s(L, L->top.p, t); ------------------ | | 691| 11|#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) | | ------------------ | | | | 687| 11| { TValue *io = (obj); Table *x_ = (x); \ | | | | 688| 11| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 72| 11|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 390| 11|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 11|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 114| 11|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 689| 11| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 11| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 11|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 11| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 767| 11| api_incr_top(L); ------------------ | | 16| 11|#define api_incr_top(L) {L->top.p++; \ | | 17| 11| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 11|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 11|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 18| 11| "stack overflow");} ------------------ 768| 11| if (narray > 0 || nrec > 0) ------------------ | Branch (768:7): [True: 0, False: 11] | Branch (768:21): [True: 11, False: 0] ------------------ 769| 11| luaH_resize(L, t, narray, nrec); 770| 11| luaC_checkGC(L); ------------------ | | 172| 11|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 11| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 11|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 11] | | | | ------------------ | | | | 169| 11| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 11|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 771| 11| lua_unlock(L); ------------------ | | 265| 11|#define lua_unlock(L) ((void) 0) ------------------ 772| 11|} lua_setfield: 871| 44|LUA_API void lua_setfield (lua_State *L, int idx, const char *k) { 872| 44| lua_lock(L); /* unlock done in 'auxsetstr' */ ------------------ | | 264| 44|#define lua_lock(L) ((void) 0) ------------------ 873| 44| auxsetstr(L, index2value(L, idx), k); 874| 44|} lua_setmetatable: 933| 11|LUA_API int lua_setmetatable (lua_State *L, int objindex) { 934| 11| TValue *obj; 935| 11| Table *mt; 936| 11| lua_lock(L); ------------------ | | 264| 11|#define lua_lock(L) ((void) 0) ------------------ 937| 11| api_checknelems(L, 1); ------------------ | | 33| 11| api_check(L, (n) < (L->top.p - L->ci->func.p), \ | | ------------------ | | | | 126| 11|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 11|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 34| 11| "not enough elements in the stack") ------------------ 938| 11| obj = index2value(L, objindex); 939| 11| if (ttisnil(s2v(L->top.p - 1))) ------------------ | | 193| 11|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 11|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 11|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 11|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 11] | | | | ------------------ | | ------------------ ------------------ 940| 0| mt = NULL; 941| 11| else { 942| 11| api_check(L, ttistable(s2v(L->top.p - 1)), "table expected"); ------------------ | | 126| 11|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 11|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 943| 11| mt = hvalue(s2v(L->top.p - 1)); ------------------ | | 684| 11|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 11|#define check_exp(c,e) (e) | | ------------------ ------------------ 944| 11| } 945| 11| switch (ttype(obj)) { ------------------ | | 87| 11|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 11|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 946| 0| case LUA_TTABLE: { ------------------ | | 70| 0|#define LUA_TTABLE 5 ------------------ | Branch (946:5): [True: 0, False: 11] ------------------ 947| 0| hvalue(obj)->metatable = mt; ------------------ | | 684| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 948| 0| if (mt) { ------------------ | Branch (948:11): [True: 0, False: 0] ------------------ 949| 0| luaC_objbarrier(L, gcvalue(obj), mt); ------------------ | | 175| 0|#define luaC_objbarrier(L,p,o) ( \ | | 176| 0| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 0| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 950| 0| luaC_checkfinalizer(L, gcvalue(obj), mt); ------------------ | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 951| 0| } 952| 0| break; 953| 0| } 954| 11| case LUA_TUSERDATA: { ------------------ | | 72| 11|#define LUA_TUSERDATA 7 ------------------ | Branch (954:5): [True: 11, False: 0] ------------------ 955| 11| uvalue(obj)->metatable = mt; ------------------ | | 437| 11|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 115| 11|#define check_exp(c,e) (e) | | ------------------ ------------------ 956| 11| if (mt) { ------------------ | Branch (956:11): [True: 11, False: 0] ------------------ 957| 11| luaC_objbarrier(L, uvalue(obj), mt); ------------------ | | 175| 11|#define luaC_objbarrier(L,p,o) ( \ | | 176| 11| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 11|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 11|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 22|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 11] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 11| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 11|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 11|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 958| 11| luaC_checkfinalizer(L, gcvalue(obj), mt); ------------------ | | 305| 11|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 11|#define check_exp(c,e) (e) | | ------------------ ------------------ 959| 11| } 960| 11| break; 961| 0| } 962| 0| default: { ------------------ | Branch (962:5): [True: 0, False: 11] ------------------ 963| 0| G(L)->mt[ttype(obj)] = mt; ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ G(L)->mt[ttype(obj)] = mt; ------------------ | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 964| 0| break; 965| 0| } 966| 11| } 967| 11| L->top.p--; 968| 11| lua_unlock(L); ------------------ | | 265| 11|#define lua_unlock(L) ((void) 0) ------------------ 969| 11| return 1; 970| 11|} lua_pcallk: 1044| 40| lua_KContext ctx, lua_KFunction k) { 1045| 40| struct CallS c; 1046| 40| int status; 1047| 40| ptrdiff_t func; 1048| 40| lua_lock(L); ------------------ | | 264| 40|#define lua_lock(L) ((void) 0) ------------------ 1049| 40| api_check(L, k == NULL || !isLua(L->ci), ------------------ | | 126| 40|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 40|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 40|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1050| 40| "cannot use continuations inside hooks"); 1051| 40| api_checknelems(L, nargs+1); ------------------ | | 33| 40| api_check(L, (n) < (L->top.p - L->ci->func.p), \ | | ------------------ | | | | 126| 40|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 40|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 40|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 34| 40| "not enough elements in the stack") ------------------ 1052| 40| api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread"); ------------------ | | 126| 40|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 40|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 40|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1053| 40| checkresults(L, nargs, nresults); ------------------ | | 999| 40| api_check(L, (nr) == LUA_MULTRET \ | | ------------------ | | | | 126| 40|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 40|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 40|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1000| 40| || (L->ci->top.p - L->top.p >= (nr) - (na)), \ | | 1001| 40| "results from function overflow current stack size") ------------------ 1054| 40| if (errfunc == 0) ------------------ | Branch (1054:7): [True: 0, False: 40] ------------------ 1055| 0| func = 0; 1056| 40| else { 1057| 40| StkId o = index2stack(L, errfunc); 1058| 40| api_check(L, ttisfunction(s2v(o)), "error handler must be a function"); ------------------ | | 126| 40|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 40|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 40|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1059| 40| func = savestack(L, o); ------------------ | | 36| 40|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 40|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 40|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 40|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 40|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1060| 40| } 1061| 40| c.func = L->top.p - (nargs+1); /* function to be called */ 1062| 40| if (k == NULL || !yieldable(L)) { /* no continuation or no yieldable? */ ------------------ | | 104| 0|#define yieldable(L) (((L)->nCcalls & 0xffff0000) == 0) ------------------ | Branch (1062:7): [True: 40, False: 0] | Branch (1062:20): [True: 0, False: 0] ------------------ 1063| 40| c.nresults = nresults; /* do a 'conventional' protected call */ 1064| 40| status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func); ------------------ | | 36| 40|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 40|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 40|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 40|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 40|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1065| 40| } 1066| 0| else { /* prepare continuation (call is already protected by 'resume') */ 1067| 0| CallInfo *ci = L->ci; 1068| 0| ci->u.c.k = k; /* save continuation */ 1069| 0| ci->u.c.ctx = ctx; /* save context */ 1070| | /* save information for error recovery */ 1071| 0| ci->u2.funcidx = cast_int(savestack(L, c.func)); ------------------ | | 141| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1072| 0| ci->u.c.old_errfunc = L->errfunc; 1073| 0| L->errfunc = func; 1074| 0| setoah(ci->callstatus, L->allowhook); /* save value of 'allowhook' */ ------------------ | | 247| 0|#define setoah(st,v) ((st) = ((st) & ~CIST_OAH) | (v)) | | ------------------ | | | | 210| 0|#define CIST_OAH (1<<0) /* original value of 'allowhook' */ | | ------------------ ------------------ 1075| 0| ci->callstatus |= CIST_YPCALL; /* function can do error recovery */ ------------------ | | 214| 0|#define CIST_YPCALL (1<<4) /* doing a yieldable protected call */ ------------------ 1076| 0| luaD_call(L, c.func, nresults); /* do the call */ 1077| 0| ci->callstatus &= ~CIST_YPCALL; ------------------ | | 214| 0|#define CIST_YPCALL (1<<4) /* doing a yieldable protected call */ ------------------ 1078| 0| L->errfunc = ci->u.c.old_errfunc; 1079| 0| status = LUA_OK; /* if it is here, there were no errors */ ------------------ | | 49| 0|#define LUA_OK 0 ------------------ 1080| 0| } 1081| 40| adjustresults(L, nresults); ------------------ | | 27| 40| { if ((nres) <= LUA_MULTRET && L->ci->top.p < L->top.p) \ | | ------------------ | | | | 36| 80|#define LUA_MULTRET (-1) | | ------------------ | | | Branch (27:11): [True: 0, False: 40] | | | Branch (27:36): [True: 0, False: 0] | | ------------------ | | 28| 40| L->ci->top.p = L->top.p; } ------------------ 1082| 40| lua_unlock(L); ------------------ | | 265| 40|#define lua_unlock(L) ((void) 0) ------------------ 1083| 40| return status; 1084| 40|} lua_load: 1088| 258| const char *chunkname, const char *mode) { 1089| 258| ZIO z; 1090| 258| int status; 1091| 258| lua_lock(L); ------------------ | | 264| 258|#define lua_lock(L) ((void) 0) ------------------ 1092| 258| if (!chunkname) chunkname = "?"; ------------------ | Branch (1092:7): [True: 0, False: 258] ------------------ 1093| 258| luaZ_init(L, &z, reader, data); 1094| 258| status = luaD_protectedparser(L, &z, chunkname, mode); 1095| 258| if (status == LUA_OK) { /* no errors? */ ------------------ | | 49| 258|#define LUA_OK 0 ------------------ | Branch (1095:7): [True: 40, False: 218] ------------------ 1096| 40| LClosure *f = clLvalue(s2v(L->top.p - 1)); /* get new function */ ------------------ | | 604| 40|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | ------------------ | | | | 115| 40|#define check_exp(c,e) (e) | | ------------------ ------------------ 1097| 40| if (f->nupvalues >= 1) { /* does it have an upvalue? */ ------------------ | Branch (1097:9): [True: 40, False: 0] ------------------ 1098| | /* get global table from registry */ 1099| 40| const TValue *gt = getGtable(L); ------------------ | | 663| 40| (&hvalue(&G(L)->l_registry)->array[LUA_RIDX_GLOBALS - 1]) | | ------------------ | | | | 684| 40|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 40|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | (&hvalue(&G(L)->l_registry)->array[LUA_RIDX_GLOBALS - 1]) | | ------------------ | | | | 85| 40|#define LUA_RIDX_GLOBALS 2 | | ------------------ ------------------ 1100| | /* set global table as 1st upvalue of 'f' (may be LUA_ENV) */ 1101| 40| setobj(L, f->upvals[0]->v.p, gt); ------------------ | | 119| 40| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 40| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 40|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 40| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 40| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 40|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 40| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 40|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 1102| 40| luaC_barrier(L, f->upvals[0], gt); ------------------ | | 179| 40|#define luaC_barrier(L,p,v) ( \ | | 180| 40| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 40|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 40|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 40|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 40, False: 0] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 40|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 40| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 40|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 40|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 80|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 40] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 177| 40| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 40|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 40|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1103| 40| } 1104| 40| } 1105| 258| lua_unlock(L); ------------------ | | 265| 258|#define lua_unlock(L) ((void) 0) ------------------ 1106| 258| return status; 1107| 258|} lua_toclose: 1270| 11|LUA_API void lua_toclose (lua_State *L, int idx) { 1271| 11| int nresults; 1272| 11| StkId o; 1273| 11| lua_lock(L); ------------------ | | 264| 11|#define lua_lock(L) ((void) 0) ------------------ 1274| 11| o = index2stack(L, idx); 1275| 11| nresults = L->ci->nresults; 1276| 11| api_check(L, L->tbclist.p < o, "given index below or equal a marked one"); ------------------ | | 126| 11|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 11|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1277| 11| luaF_newtbcupval(L, o); /* create new to-be-closed upvalue */ 1278| 11| if (!hastocloseCfunc(nresults)) /* function not marked yet? */ ------------------ | | 46| 11|#define hastocloseCfunc(n) ((n) < LUA_MULTRET) | | ------------------ | | | | 36| 11|#define LUA_MULTRET (-1) | | ------------------ ------------------ | Branch (1278:7): [True: 11, False: 0] ------------------ 1279| 11| L->ci->nresults = codeNresults(nresults); /* mark it */ ------------------ | | 49| 11|#define codeNresults(n) (-(n) - 3) ------------------ 1280| 11| lua_assert(hastocloseCfunc(L->ci->nresults)); ------------------ | | 114| 11|#define lua_assert(c) ((void)0) ------------------ 1281| 11| lua_unlock(L); ------------------ | | 265| 11|#define lua_unlock(L) ((void) 0) ------------------ 1282| 11|} lua_getallocf: 1309| 44|LUA_API lua_Alloc lua_getallocf (lua_State *L, void **ud) { 1310| 44| lua_Alloc f; 1311| 44| lua_lock(L); ------------------ | | 264| 44|#define lua_lock(L) ((void) 0) ------------------ 1312| 44| if (ud) *ud = G(L)->ud; ------------------ | | 335| 44|#define G(L) (L->l_G) ------------------ | Branch (1312:7): [True: 44, False: 0] ------------------ 1313| 44| f = G(L)->frealloc; ------------------ | | 335| 44|#define G(L) (L->l_G) ------------------ 1314| 44| lua_unlock(L); ------------------ | | 265| 44|#define lua_unlock(L) ((void) 0) ------------------ 1315| 44| return f; 1316| 44|} lua_setwarnf: 1327| 258|void lua_setwarnf (lua_State *L, lua_WarnFunction f, void *ud) { 1328| 258| lua_lock(L); ------------------ | | 264| 258|#define lua_lock(L) ((void) 0) ------------------ 1329| 258| G(L)->ud_warn = ud; ------------------ | | 335| 258|#define G(L) (L->l_G) ------------------ 1330| 258| G(L)->warnf = f; ------------------ | | 335| 258|#define G(L) (L->l_G) ------------------ 1331| 258| lua_unlock(L); ------------------ | | 265| 258|#define lua_unlock(L) ((void) 0) ------------------ 1332| 258|} lua_newuserdatauv: 1343| 11|LUA_API void *lua_newuserdatauv (lua_State *L, size_t size, int nuvalue) { 1344| 11| Udata *u; 1345| 11| lua_lock(L); ------------------ | | 264| 11|#define lua_lock(L) ((void) 0) ------------------ 1346| 11| api_check(L, 0 <= nuvalue && nuvalue < USHRT_MAX, "invalid value"); ------------------ | | 126| 11|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 11|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1347| 11| u = luaS_newudata(L, size, nuvalue); 1348| 11| setuvalue(L, s2v(L->top.p), u); ------------------ | | 445| 11| { TValue *io = (obj); Udata *x_ = (x); \ | | 446| 11| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \ | | ------------------ | | | | 72| 11|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \ | | ------------------ | | | | 390| 11|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 11|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VUSERDATA)); \ | | ------------------ | | | | 114| 11|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 447| 11| checkliveness(L,io); } | | ------------------ | | | | 107| 11| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 11|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 11| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 1349| 11| api_incr_top(L); ------------------ | | 16| 11|#define api_incr_top(L) {L->top.p++; \ | | 17| 11| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 11|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 11|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 18| 11| "stack overflow");} ------------------ 1350| 11| luaC_checkGC(L); ------------------ | | 172| 11|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 11| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 11|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 8, False: 3] | | | | ------------------ | | | | 169| 11| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 11|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1351| 11| lua_unlock(L); ------------------ | | 265| 11|#define lua_unlock(L) ((void) 0) ------------------ 1352| 11| return getudatamem(u); ------------------ | | 495| 11|#define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 146| 11|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 11|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 491| 11| ((nuv) == 0 ? offsetof(Udata0, bindata) \ | | | | ------------------ | | | | | Branch (491:3): [True: 11, False: 0] | | | | ------------------ | | | | 492| 11| : offsetof(Udata, uv) + (sizeof(UValue) * (nuv))) | | ------------------ ------------------ 1353| 11|} lapi.c:index2stack: 95| 203|l_sinline StkId index2stack (lua_State *L, int idx) { 96| 203| CallInfo *ci = L->ci; 97| 203| if (idx > 0) { ------------------ | Branch (97:7): [True: 120, False: 83] ------------------ 98| 120| StkId o = ci->func.p + idx; 99| 120| api_check(L, o < L->top.p, "invalid index"); ------------------ | | 126| 120|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 120|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 120|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 100| 120| return o; 101| 120| } 102| 83| else { /* non-positive index */ 103| 83| api_check(L, idx != 0 && -idx <= L->top.p - (ci->func.p + 1), ------------------ | | 126| 83|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 83|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 83|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 104| 83| "invalid index"); 105| 83| api_check(L, !ispseudo(idx), "invalid index"); ------------------ | | 126| 83|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 83|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 83|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 106| 83| return L->top.p + idx; 107| 83| } 108| 203|} lapi.c:reverse: 227| 423|l_sinline void reverse (lua_State *L, StkId from, StkId to) { 228| 541| for (; from < to; from++, to--) { ------------------ | Branch (228:10): [True: 118, False: 423] ------------------ 229| 118| TValue temp; 230| 118| setobj(L, &temp, s2v(from)); ------------------ | | 119| 118| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 118| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 118|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 118| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 118| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 118|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 118| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 118|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 231| 118| setobjs2s(L, from, to); ------------------ | | 129| 118|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 118| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 118| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 118|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 118| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 118| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 118|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 118| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 118|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 232| 118| setobj2s(L, to, &temp); ------------------ | | 131| 118|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 118| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 118| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 118|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 118| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 118| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 118|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 118| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 118|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 233| 118| } 234| 423|} lapi.c:index2value: 60| 658|static TValue *index2value (lua_State *L, int idx) { 61| 658| CallInfo *ci = L->ci; 62| 658| if (idx > 0) { ------------------ | Branch (62:7): [True: 61, False: 597] ------------------ 63| 61| StkId o = ci->func.p + idx; 64| 61| api_check(L, idx <= ci->top.p - (ci->func.p + 1), "unacceptable index"); ------------------ | | 126| 61|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 61|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 61|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 65| 61| if (o >= L->top.p) return &G(L)->nilvalue; ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ | Branch (65:9): [True: 0, False: 61] ------------------ 66| 61| else return s2v(o); ------------------ | | 172| 61|#define s2v(o) (&(o)->val) ------------------ 67| 61| } 68| 597| else if (!ispseudo(idx)) { /* negative index */ ------------------ | | 50| 597|#define ispseudo(i) ((i) <= LUA_REGISTRYINDEX) | | ------------------ | | | | 44| 597|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | | | ------------------ | | | | | | 740| 597|#define LUAI_MAXSTACK 1000000 | | | | ------------------ | | ------------------ ------------------ | Branch (68:12): [True: 515, False: 82] ------------------ 69| 515| api_check(L, idx != 0 && -idx <= L->top.p - (ci->func.p + 1), ------------------ | | 126| 515|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 515|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 515|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 70| 515| "invalid index"); 71| 515| return s2v(L->top.p + idx); ------------------ | | 172| 515|#define s2v(o) (&(o)->val) ------------------ 72| 515| } 73| 82| else if (idx == LUA_REGISTRYINDEX) ------------------ | | 44| 82|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 740| 82|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ | Branch (73:12): [True: 82, False: 0] ------------------ 74| 82| return &G(L)->l_registry; ------------------ | | 335| 82|#define G(L) (L->l_G) ------------------ 75| 0| else { /* upvalues */ 76| 0| idx = LUA_REGISTRYINDEX - idx; ------------------ | | 44| 0|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 740| 0|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ 77| 0| api_check(L, idx <= MAXUPVAL + 1, "upvalue index too large"); ------------------ | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 0|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 78| 0| if (ttisCclosure(s2v(ci->func.p))) { /* C closure? */ ------------------ | | 597| 0|#define ttisCclosure(o) checktag((o), ctb(LUA_VCCL)) | | ------------------ | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 79| 0| CClosure *func = clCvalue(s2v(ci->func.p)); ------------------ | | 606| 0|#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 80| 0| return (idx <= func->nupvalues) ? &func->upvalue[idx-1] ------------------ | Branch (80:14): [True: 0, False: 0] ------------------ 81| 0| : &G(L)->nilvalue; ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ 82| 0| } 83| 0| else { /* light C function or Lua function (through a hook)?) */ 84| 0| api_check(L, ttislcf(s2v(ci->func.p)), "caller not a C function"); ------------------ | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 0|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 85| 0| return &G(L)->nilvalue; /* no upvalues */ ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ 86| 0| } 87| 0| } 88| 658|} lapi.c:touserdata: 447| 44|l_sinline void *touserdata (const TValue *o) { 448| 44| switch (ttype(o)) { ------------------ | | 87| 44|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 44|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 449| 44| case LUA_TUSERDATA: return getudatamem(uvalue(o)); ------------------ | | 72| 44|#define LUA_TUSERDATA 7 ------------------ case LUA_TUSERDATA: return getudatamem(uvalue(o)); ------------------ | | 495| 44|#define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 146| 44|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 44|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define getudatamem(u) (cast_charp(u) + udatamemoffset((u)->nuvalue)) | | ------------------ | | | | 491| 44| ((nuv) == 0 ? offsetof(Udata0, bindata) \ | | | | ------------------ | | | | | Branch (491:3): [True: 44, False: 0] | | | | ------------------ | | | | 492| 44| : offsetof(Udata, uv) + (sizeof(UValue) * (nuv))) | | ------------------ ------------------ | Branch (449:5): [True: 44, False: 0] ------------------ 450| 0| case LUA_TLIGHTUSERDATA: return pvalue(o); ------------------ | | 67| 0|#define LUA_TLIGHTUSERDATA 2 ------------------ case LUA_TLIGHTUSERDATA: return pvalue(o); ------------------ | | 436| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (450:5): [True: 0, False: 44] ------------------ 451| 0| default: return NULL; ------------------ | Branch (451:5): [True: 0, False: 44] ------------------ 452| 44| } 453| 44|} lapi.c:auxgetstr: 639| 71|l_sinline int auxgetstr (lua_State *L, const TValue *t, const char *k) { 640| 71| const TValue *slot; 641| 71| TString *str = luaS_new(L, k); 642| 71| if (luaV_fastget(L, t, str, slot, luaH_getstr)) { ------------------ | | 86| 71| (!ttistable(t) \ | | ------------------ | | | | 682| 71|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 71|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 71|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 71] | | | Branch (86:4): [True: 0, False: 71] | | ------------------ | | 87| 71| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 71| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 684| 71|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 71|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 71| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 71|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 71|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 71|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 71|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 71|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 643| 0| setobj2s(L, L->top.p, slot); ------------------ | | 131| 0|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 644| 0| api_incr_top(L); ------------------ | | 16| 0|#define api_incr_top(L) {L->top.p++; \ | | 17| 0| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 0|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 18| 0| "stack overflow");} ------------------ 645| 0| } 646| 71| else { 647| 71| setsvalue2s(L, L->top.p, str); ------------------ | | 377| 71|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 71| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 71| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 71|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 71|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 71|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 71|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 71| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 71| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 71|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 71| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 648| 71| api_incr_top(L); ------------------ | | 16| 71|#define api_incr_top(L) {L->top.p++; \ | | 17| 71| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 71|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 71|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 71|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 18| 71| "stack overflow");} ------------------ 649| 71| luaV_finishget(L, t, s2v(L->top.p - 1), L->top.p - 1, slot); ------------------ | | 172| 71|#define s2v(o) (&(o)->val) ------------------ 650| 71| } 651| 71| lua_unlock(L); ------------------ | | 265| 71|#define lua_unlock(L) ((void) 0) ------------------ 652| 71| return ttype(s2v(L->top.p - 1)); ------------------ | | 87| 71|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 71|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 653| 71|} lapi.c:auxsetstr: 829| 44|static void auxsetstr (lua_State *L, const TValue *t, const char *k) { 830| 44| const TValue *slot; 831| 44| TString *str = luaS_new(L, k); 832| 44| api_checknelems(L, 1); ------------------ | | 33| 44| api_check(L, (n) < (L->top.p - L->ci->func.p), \ | | ------------------ | | | | 126| 44|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 44|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 44|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 34| 44| "not enough elements in the stack") ------------------ 833| 44| if (luaV_fastget(L, t, str, slot, luaH_getstr)) { ------------------ | | 86| 44| (!ttistable(t) \ | | ------------------ | | | | 682| 44|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 44|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 44|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 44] | | | Branch (86:4): [True: 0, False: 44] | | ------------------ | | 87| 44| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 44| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 684| 44|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 44|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 44| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 44|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 44|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 44|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 44|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 44|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 834| 0| luaV_finishfastset(L, t, slot, s2v(L->top.p - 1)); ------------------ | | 109| 0| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 0|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | | | ------------------ | | | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 0| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 0|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 0| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 0|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 0| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 835| 0| L->top.p--; /* pop value */ 836| 0| } 837| 44| else { 838| 44| setsvalue2s(L, L->top.p, str); /* push 'str' (to make it a TValue) */ ------------------ | | 377| 44|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 44| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 44| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 44|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 44|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 44|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 44|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 44| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 44| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 44|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 44| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 839| 44| api_incr_top(L); ------------------ | | 16| 44|#define api_incr_top(L) {L->top.p++; \ | | 17| 44| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 44|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 44|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 44|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 18| 44| "stack overflow");} ------------------ 840| 44| luaV_finishset(L, t, s2v(L->top.p - 1), s2v(L->top.p - 2), slot); ------------------ | | 172| 44|#define s2v(o) (&(o)->val) ------------------ luaV_finishset(L, t, s2v(L->top.p - 1), s2v(L->top.p - 2), slot); ------------------ | | 172| 44|#define s2v(o) (&(o)->val) ------------------ 841| 44| L->top.p -= 2; /* pop value and key */ 842| 44| } 843| 44| lua_unlock(L); /* lock done by caller */ ------------------ | | 265| 44|#define lua_unlock(L) ((void) 0) ------------------ 844| 44|} lapi.c:f_call: 1036| 40|static void f_call (lua_State *L, void *ud) { 1037| 40| struct CallS *c = cast(struct CallS *, ud); ------------------ | | 136| 40|#define cast(t, exp) ((t)(exp)) ------------------ 1038| 40| luaD_callnoyield(L, c->func, c->nresults); 1039| 40|} luaL_traceback: 132| 39| const char *msg, int level) { 133| 39| luaL_Buffer b; 134| 39| lua_Debug ar; 135| 39| int last = lastlevel(L1); 136| 39| int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1; ------------------ | | 43| 39|#define LEVELS1 10 /* size of the first part of the stack */ ------------------ int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1; ------------------ | | 44| 39|#define LEVELS2 11 /* size of the second part of the stack */ ------------------ int limit2show = (last - level > LEVELS1 + LEVELS2) ? LEVELS1 : -1; ------------------ | | 43| 1|#define LEVELS1 10 /* size of the first part of the stack */ ------------------ | Branch (136:20): [True: 1, False: 38] ------------------ 137| 39| luaL_buffinit(L, &b); 138| 39| if (msg) { ------------------ | Branch (138:7): [True: 39, False: 0] ------------------ 139| 39| luaL_addstring(&b, msg); 140| 39| luaL_addchar(&b, '\n'); ------------------ | | 208| 39| ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \ | | ------------------ | | | Branch (208:11): [True: 28, False: 11] | | | Branch (208:33): [True: 11, False: 0] | | ------------------ | | 209| 39| ((B)->b[(B)->n++] = (c))) ------------------ 141| 39| } 142| 39| luaL_addstring(&b, "stack traceback:"); 143| 100| while (lua_getstack(L1, level++, &ar)) { ------------------ | Branch (143:10): [True: 61, False: 39] ------------------ 144| 61| if (limit2show-- == 0) { /* too many levels? */ ------------------ | Branch (144:9): [True: 1, False: 60] ------------------ 145| 1| int n = last - level - LEVELS2 + 1; /* number of levels to skip */ ------------------ | | 44| 1|#define LEVELS2 11 /* size of the second part of the stack */ ------------------ 146| 1| lua_pushfstring(L, "\n\t...\t(skipping %d levels)", n); 147| 1| luaL_addvalue(&b); /* add warning about skip */ 148| 1| level += n; /* and skip to last levels */ 149| 1| } 150| 60| else { 151| 60| lua_getinfo(L1, "Slnt", &ar); 152| 60| if (ar.currentline <= 0) ------------------ | Branch (152:11): [True: 0, False: 60] ------------------ 153| 0| lua_pushfstring(L, "\n\t%s: in ", ar.short_src); 154| 60| else 155| 60| lua_pushfstring(L, "\n\t%s:%d: in ", ar.short_src, ar.currentline); 156| 60| luaL_addvalue(&b); 157| 60| pushfuncname(L, &ar); 158| 60| luaL_addvalue(&b); 159| 60| if (ar.istailcall) ------------------ | Branch (159:11): [True: 0, False: 60] ------------------ 160| 0| luaL_addstring(&b, "\n\t(...tail calls...)"); 161| 60| } 162| 61| } 163| 39| luaL_pushresult(&b); 164| 39|} luaL_newmetatable: 311| 11|LUALIB_API int luaL_newmetatable (lua_State *L, const char *tname) { 312| 11| if (luaL_getmetatable(L, tname) != LUA_TNIL) /* name already in use? */ ------------------ | | 150| 11|#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) | | ------------------ | | | | 44| 11|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | | | ------------------ | | | | | | 740| 11|#define LUAI_MAXSTACK 1000000 | | | | ------------------ | | ------------------ ------------------ if (luaL_getmetatable(L, tname) != LUA_TNIL) /* name already in use? */ ------------------ | | 65| 11|#define LUA_TNIL 0 ------------------ | Branch (312:7): [True: 0, False: 11] ------------------ 313| 0| return 0; /* leave previous value on top, but return 0 */ 314| 11| lua_pop(L, 1); ------------------ | | 375| 11|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 315| 11| lua_createtable(L, 0, 2); /* create metatable */ 316| 11| lua_pushstring(L, tname); 317| 11| lua_setfield(L, -2, "__name"); /* metatable.__name = tname */ 318| 11| lua_pushvalue(L, -1); 319| 11| lua_setfield(L, LUA_REGISTRYINDEX, tname); /* registry.name = metatable */ ------------------ | | 44| 11|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 740| 11|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ 320| 11| return 1; 321| 11|} luaL_checkstack: 380| 11|LUALIB_API void luaL_checkstack (lua_State *L, int space, const char *msg) { 381| 11| if (l_unlikely(!lua_checkstack(L, space))) { ------------------ | | 688| 11|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 11|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 11] | | | | ------------------ | | ------------------ ------------------ 382| 0| if (msg) ------------------ | Branch (382:9): [True: 0, False: 0] ------------------ 383| 0| luaL_error(L, "stack overflow (%s)", msg); 384| 0| else 385| 0| luaL_error(L, "stack overflow"); 386| 0| } 387| 11|} luaL_prepbuffsize: 575| 11|LUALIB_API char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz) { 576| 11| return prepbuffsize(B, sz, -1); 577| 11|} luaL_addlstring: 580| 78|LUALIB_API void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l) { 581| 78| if (l > 0) { /* avoid 'memcpy' when 's' can be NULL */ ------------------ | Branch (581:7): [True: 78, False: 0] ------------------ 582| 78| char *b = prepbuffsize(B, l, -1); 583| 78| memcpy(b, s, l * sizeof(char)); 584| 78| luaL_addsize(B, l); ------------------ | | 211| 78|#define luaL_addsize(B,s) ((B)->n += (s)) ------------------ 585| 78| } 586| 78|} luaL_addstring: 589| 78|LUALIB_API void luaL_addstring (luaL_Buffer *B, const char *s) { 590| 78| luaL_addlstring(B, s, strlen(s)); 591| 78|} luaL_pushresult: 594| 39|LUALIB_API void luaL_pushresult (luaL_Buffer *B) { 595| 39| lua_State *L = B->L; 596| 39| checkbufferlevel(B, -1); ------------------ | | 523| 39| lua_assert(buffonstack(B) ? lua_touserdata(B->L, idx) != NULL \ | | ------------------ | | | | 178| 39| #define lua_assert(c) ((void)0) | | ------------------ | | 524| 39| : lua_touserdata(B->L, idx) == (void*)B) ------------------ 597| 39| lua_pushlstring(L, B->b, B->n); 598| 39| if (buffonstack(B)) ------------------ | | 515| 39|#define buffonstack(B) ((B)->b != (B)->init.b) | | ------------------ | | | Branch (515:24): [True: 11, False: 28] | | ------------------ ------------------ 599| 11| lua_closeslot(L, -2); /* close the box */ 600| 39| lua_remove(L, -2); /* remove box or placeholder from the stack */ ------------------ | | 402| 39|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 375| 39|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 601| 39|} luaL_addvalue: 619| 121|LUALIB_API void luaL_addvalue (luaL_Buffer *B) { 620| 121| lua_State *L = B->L; 621| 121| size_t len; 622| 121| const char *s = lua_tolstring(L, -1, &len); 623| 121| char *b = prepbuffsize(B, len, -2); 624| 121| memcpy(b, s, len * sizeof(char)); 625| 121| luaL_addsize(B, len); ------------------ | | 211| 121|#define luaL_addsize(B,s) ((B)->n += (s)) ------------------ 626| 121| lua_pop(L, 1); /* pop string */ ------------------ | | 375| 121|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 627| 121|} luaL_buffinit: 630| 39|LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) { 631| 39| B->L = L; 632| 39| B->b = B->init.b; 633| 39| B->n = 0; 634| 39| B->size = LUAL_BUFFERSIZE; ------------------ | | 766| 39|#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number))) ------------------ 635| 39| lua_pushlightuserdata(L, (void*)B); /* push placeholder */ 636| 39|} luaL_loadbufferx: 835| 258| const char *name, const char *mode) { 836| 258| LoadS ls; 837| 258| ls.s = buff; 838| 258| ls.size = size; 839| 258| return lua_load(L, getS, &ls, name, mode); 840| 258|} luaL_setfuncs: 933| 11|LUALIB_API void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup) { 934| 11| luaL_checkstack(L, nup, "too many upvalues"); 935| 33| for (; l->name != NULL; l++) { /* fill the table with given functions */ ------------------ | Branch (935:10): [True: 22, False: 11] ------------------ 936| 22| if (l->func == NULL) /* place holder? */ ------------------ | Branch (936:9): [True: 0, False: 22] ------------------ 937| 0| lua_pushboolean(L, 0); 938| 22| else { 939| 22| int i; 940| 22| for (i = 0; i < nup; i++) /* copy upvalues to the top */ ------------------ | Branch (940:19): [True: 0, False: 22] ------------------ 941| 0| lua_pushvalue(L, -nup); 942| 22| lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */ 943| 22| } 944| 22| lua_setfield(L, -(nup + 2), l->name); 945| 22| } 946| 11| lua_pop(L, nup); /* remove upvalues */ ------------------ | | 375| 11|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 947| 11|} luaL_newstate: 1094| 258|LUALIB_API lua_State *luaL_newstate (void) { 1095| 258| lua_State *L = lua_newstate(l_alloc, NULL); 1096| 258| if (l_likely(L)) { ------------------ | | 687| 258|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 675| 258|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (675:25): [True: 258, False: 0] | | | | ------------------ | | ------------------ ------------------ 1097| 258| lua_atpanic(L, &panic); 1098| 258| lua_setwarnf(L, warnfoff, L); /* default is warnings off */ 1099| 258| } 1100| 258| return L; 1101| 258|} lauxlib.c:lastlevel: 116| 39|static int lastlevel (lua_State *L) { 117| 39| lua_Debug ar; 118| 39| int li = 1, le = 1; 119| | /* find an upper bound */ 120| 89| while (lua_getstack(L, le, &ar)) { li = le; le *= 2; } ------------------ | Branch (120:10): [True: 50, False: 39] ------------------ 121| | /* do a binary search */ 122| 88| while (li < le) { ------------------ | Branch (122:10): [True: 49, False: 39] ------------------ 123| 49| int m = (li + le)/2; 124| 49| if (lua_getstack(L, m, &ar)) li = m + 1; ------------------ | Branch (124:9): [True: 43, False: 6] ------------------ 125| 6| else le = m; 126| 49| } 127| 39| return le - 1; 128| 39|} lauxlib.c:pushfuncname: 100| 60|static void pushfuncname (lua_State *L, lua_Debug *ar) { 101| 60| if (pushglobalfuncname(L, ar)) { /* try first a global name */ ------------------ | Branch (101:7): [True: 0, False: 60] ------------------ 102| 0| lua_pushfstring(L, "function '%s'", lua_tostring(L, -1)); ------------------ | | 397| 0|#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) ------------------ 103| 0| lua_remove(L, -2); /* remove name */ ------------------ | | 402| 0|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 375| 0|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 104| 0| } 105| 60| else if (*ar->namewhat != '\0') /* is there a name from code? */ ------------------ | Branch (105:12): [True: 21, False: 39] ------------------ 106| 21| lua_pushfstring(L, "%s '%s'", ar->namewhat, ar->name); /* use it */ 107| 39| else if (*ar->what == 'm') /* main? */ ------------------ | Branch (107:12): [True: 39, False: 0] ------------------ 108| 39| lua_pushliteral(L, "main chunk"); ------------------ | | 392| 39|#define lua_pushliteral(L, s) lua_pushstring(L, "" s) ------------------ 109| 0| else if (*ar->what != 'C') /* for Lua functions, use */ ------------------ | Branch (109:12): [True: 0, False: 0] ------------------ 110| 0| lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined); 111| 0| else /* nothing left... */ 112| 0| lua_pushliteral(L, "?"); ------------------ | | 392| 0|#define lua_pushliteral(L, s) lua_pushstring(L, "" s) ------------------ 113| 60|} lauxlib.c:pushglobalfuncname: 79| 60|static int pushglobalfuncname (lua_State *L, lua_Debug *ar) { 80| 60| int top = lua_gettop(L); 81| 60| lua_getinfo(L, "f", ar); /* push function */ 82| 60| lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); ------------------ | | 44| 60|#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) | | ------------------ | | | | 740| 60|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE); ------------------ | | 31| 60|#define LUA_LOADED_TABLE "_LOADED" ------------------ 83| 60| if (findfield(L, top + 1, 2)) { ------------------ | Branch (83:7): [True: 0, False: 60] ------------------ 84| 0| const char *name = lua_tostring(L, -1); ------------------ | | 397| 0|#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) ------------------ 85| 0| if (strncmp(name, LUA_GNAME ".", 3) == 0) { /* name start with '_G.'? */ ------------------ | | 20| 0|#define LUA_GNAME "_G" ------------------ | Branch (85:9): [True: 0, False: 0] ------------------ 86| 0| lua_pushstring(L, name + 3); /* push name without prefix */ 87| 0| lua_remove(L, -2); /* remove original name */ ------------------ | | 402| 0|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 375| 0|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 88| 0| } 89| 0| lua_copy(L, -1, top + 1); /* copy name to proper place */ 90| 0| lua_settop(L, top + 1); /* remove table "loaded" and name copy */ 91| 0| return 1; 92| 0| } 93| 60| else { 94| 60| lua_settop(L, top); /* remove function and global table */ 95| 60| return 0; 96| 60| } 97| 60|} lauxlib.c:findfield: 52| 60|static int findfield (lua_State *L, int objidx, int level) { 53| 60| if (level == 0 || !lua_istable(L, -1)) ------------------ | | 384| 60|#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE) | | ------------------ | | | | 70| 60|#define LUA_TTABLE 5 | | ------------------ ------------------ | Branch (53:7): [True: 0, False: 60] | Branch (53:21): [True: 60, False: 0] ------------------ 54| 60| return 0; /* not found */ 55| 0| lua_pushnil(L); /* start 'next' loop */ 56| 0| while (lua_next(L, -2)) { /* for each pair in table */ ------------------ | Branch (56:10): [True: 0, False: 0] ------------------ 57| 0| if (lua_type(L, -2) == LUA_TSTRING) { /* ignore non-string keys */ ------------------ | | 69| 0|#define LUA_TSTRING 4 ------------------ | Branch (57:9): [True: 0, False: 0] ------------------ 58| 0| if (lua_rawequal(L, objidx, -1)) { /* found object? */ ------------------ | Branch (58:11): [True: 0, False: 0] ------------------ 59| 0| lua_pop(L, 1); /* remove value (but keep name) */ ------------------ | | 375| 0|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 60| 0| return 1; 61| 0| } 62| 0| else if (findfield(L, objidx, level - 1)) { /* try recursively */ ------------------ | Branch (62:16): [True: 0, False: 0] ------------------ 63| | /* stack: lib_name, lib_table, field_name (top) */ 64| 0| lua_pushliteral(L, "."); /* place '.' between the two names */ ------------------ | | 392| 0|#define lua_pushliteral(L, s) lua_pushstring(L, "" s) ------------------ 65| 0| lua_replace(L, -3); /* (in the slot occupied by table) */ ------------------ | | 404| 0|#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) | | ------------------ | | | | 375| 0|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 66| 0| lua_concat(L, 3); /* lib_name.field_name */ 67| 0| return 1; 68| 0| } 69| 0| } 70| 0| lua_pop(L, 1); /* remove value */ ------------------ | | 375| 0|#define lua_pop(L,n) lua_settop(L, -(n)-1) ------------------ 71| 0| } 72| 0| return 0; /* not found */ 73| 0|} lauxlib.c:prepbuffsize: 547| 210|static char *prepbuffsize (luaL_Buffer *B, size_t sz, int boxidx) { 548| 210| checkbufferlevel(B, boxidx); ------------------ | | 523| 210| lua_assert(buffonstack(B) ? lua_touserdata(B->L, idx) != NULL \ | | ------------------ | | | | 178| 210| #define lua_assert(c) ((void)0) | | ------------------ | | 524| 210| : lua_touserdata(B->L, idx) == (void*)B) ------------------ 549| 210| if (B->size - B->n >= sz) /* enough space? */ ------------------ | Branch (549:7): [True: 188, False: 22] ------------------ 550| 188| return B->b + B->n; 551| 22| else { 552| 22| lua_State *L = B->L; 553| 22| char *newbuff; 554| 22| size_t newsize = newbuffsize(B, sz); 555| | /* create larger buffer */ 556| 22| if (buffonstack(B)) /* buffer already has a box? */ ------------------ | | 515| 22|#define buffonstack(B) ((B)->b != (B)->init.b) | | ------------------ | | | Branch (515:24): [True: 11, False: 11] | | ------------------ ------------------ 557| 11| newbuff = (char *)resizebox(L, boxidx, newsize); /* resize it */ 558| 11| else { /* no box yet */ 559| 11| lua_remove(L, boxidx); /* remove placeholder */ ------------------ | | 402| 11|#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) | | ------------------ | | | | 375| 11|#define lua_pop(L,n) lua_settop(L, -(n)-1) | | ------------------ ------------------ 560| 11| newbox(L); /* create a new box */ 561| 11| lua_insert(L, boxidx); /* move box to its intended position */ ------------------ | | 400| 11|#define lua_insert(L,idx) lua_rotate(L, (idx), 1) ------------------ 562| 11| lua_toclose(L, boxidx); 563| 11| newbuff = (char *)resizebox(L, boxidx, newsize); 564| 11| memcpy(newbuff, B->b, B->n * sizeof(char)); /* copy original content */ 565| 11| } 566| 22| B->b = newbuff; 567| 22| B->size = newsize; 568| 22| return newbuff + B->n; 569| 22| } 570| 210|} lauxlib.c:newbuffsize: 532| 22|static size_t newbuffsize (luaL_Buffer *B, size_t sz) { 533| 22| size_t newsize = (B->size / 2) * 3; /* buffer size * 1.5 */ 534| 22| if (l_unlikely(MAX_SIZET - sz < B->n)) /* overflow in (B->n + sz)? */ ------------------ | | 688| 22|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 22|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 22] | | | | ------------------ | | ------------------ ------------------ 535| 0| return luaL_error(B->L, "buffer too large"); 536| 22| if (newsize < B->n + sz) /* not big enough? */ ------------------ | Branch (536:7): [True: 11, False: 11] ------------------ 537| 11| newsize = B->n + sz; 538| 22| return newsize; 539| 22|} lauxlib.c:resizebox: 473| 44|static void *resizebox (lua_State *L, int idx, size_t newsize) { 474| 44| void *ud; 475| 44| lua_Alloc allocf = lua_getallocf(L, &ud); 476| 44| UBox *box = (UBox *)lua_touserdata(L, idx); 477| 44| void *temp = allocf(ud, box->box, box->bsize, newsize); 478| 44| if (l_unlikely(temp == NULL && newsize > 0)) { /* allocation error? */ ------------------ | | 688| 44|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 66|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 44] | | | | | Branch (676:46): [True: 22, False: 22] | | | | | Branch (676:46): [True: 0, False: 22] | | | | ------------------ | | ------------------ ------------------ 479| 0| lua_pushliteral(L, "not enough memory"); ------------------ | | 392| 0|#define lua_pushliteral(L, s) lua_pushstring(L, "" s) ------------------ 480| 0| lua_error(L); /* raise a memory error */ 481| 0| } 482| 44| box->box = temp; 483| 44| box->bsize = newsize; 484| 44| return temp; 485| 44|} lauxlib.c:newbox: 501| 11|static void newbox (lua_State *L) { 502| 11| UBox *box = (UBox *)lua_newuserdatauv(L, sizeof(UBox), 0); 503| 11| box->box = NULL; 504| 11| box->bsize = 0; 505| 11| if (luaL_newmetatable(L, "_UBOX*")) /* creating metatable? */ ------------------ | Branch (505:7): [True: 11, False: 0] ------------------ 506| 11| luaL_setfuncs(L, boxmt, 0); /* set its metamethods */ 507| 11| lua_setmetatable(L, -2); 508| 11|} lauxlib.c:boxgc: 488| 22|static int boxgc (lua_State *L) { 489| 22| resizebox(L, 1, 0); 490| 22| return 0; 491| 22|} lauxlib.c:getS: 824| 351|static const char *getS (lua_State *L, void *ud, size_t *size) { 825| 351| LoadS *ls = (LoadS *)ud; 826| 351| (void)L; /* not used */ 827| 351| if (ls->size == 0) return NULL; ------------------ | Branch (827:7): [True: 93, False: 258] ------------------ 828| 258| *size = ls->size; 829| 258| ls->size = 0; 830| 258| return ls->s; 831| 351|} lauxlib.c:l_alloc: 1017| 1.17M|static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) { 1018| 1.17M| (void)ud; (void)osize; /* not used */ 1019| 1.17M| if (nsize == 0) { ------------------ | Branch (1019:7): [True: 586k, False: 592k] ------------------ 1020| 586k| free(ptr); 1021| 586k| return NULL; 1022| 586k| } 1023| 592k| else 1024| 592k| return realloc(ptr, nsize); 1025| 1.17M|} luaK_semerror: 46| 4|l_noret luaK_semerror (LexState *ls, const char *msg) { 47| 4| ls->t.token = 0; /* remove "near " from final message */ 48| 4| luaX_syntaxerror(ls, msg); 49| 4|} luaK_exp2const: 84| 1.34k|int luaK_exp2const (FuncState *fs, const expdesc *e, TValue *v) { 85| 1.34k| if (hasjumps(e)) ------------------ | | 38| 1.34k|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 64, False: 1.28k] | | ------------------ ------------------ 86| 64| return 0; /* not a constant */ 87| 1.28k| switch (e->k) { 88| 156| case VFALSE: ------------------ | Branch (88:5): [True: 156, False: 1.12k] ------------------ 89| 156| setbfvalue(v); ------------------ | | 250| 156|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 156|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 90| 156| return 1; 91| 12| case VTRUE: ------------------ | Branch (91:5): [True: 12, False: 1.27k] ------------------ 92| 12| setbtvalue(v); ------------------ | | 251| 12|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 93| 12| return 1; 94| 326| case VNIL: ------------------ | Branch (94:5): [True: 326, False: 959] ------------------ 95| 326| setnilvalue(v); ------------------ | | 200| 326|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 326|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 96| 326| return 1; 97| 504| case VKSTR: { ------------------ | Branch (97:5): [True: 504, False: 781] ------------------ 98| 504| setsvalue(fs->ls->L, v, e->u.strval); ------------------ | | 372| 504| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 504| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 504|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 504|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 504|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 504|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 504| checkliveness(L,io); } | | ------------------ | | | | 107| 504| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 504|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 504| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 99| 504| return 1; 100| 0| } 101| 0| case VCONST: { ------------------ | Branch (101:5): [True: 0, False: 1.28k] ------------------ 102| 0| setobj(fs->ls->L, v, const2val(fs, e)); ------------------ | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 0|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 103| 0| return 1; 104| 0| } 105| 287| default: return tonumeral(e, v); ------------------ | Branch (105:5): [True: 287, False: 998] ------------------ 106| 1.28k| } 107| 1.28k|} luaK_nil: 131| 715k|void luaK_nil (FuncState *fs, int from, int n) { 132| 715k| int l = from + n - 1; /* last register to set nil */ 133| 715k| Instruction *previous = previousinstruction(fs); 134| 715k| if (GET_OPCODE(*previous) == OP_LOADNIL) { /* previous is LOADNIL? */ ------------------ | | 114| 715k|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 715k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (134:7): [True: 279, False: 715k] ------------------ 135| 279| int pfrom = GETARG_A(*previous); /* get previous range */ ------------------ | | 125| 279|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 279|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 279|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 279|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 136| 279| int pl = pfrom + GETARG_B(*previous); ------------------ | | 128| 279|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 279|#define check_exp(c,e) (e) | | ------------------ ------------------ 137| 279| if ((pfrom <= from && from <= pl + 1) || ------------------ | Branch (137:10): [True: 279, False: 0] | Branch (137:27): [True: 279, False: 0] ------------------ 138| 279| (from <= pfrom && pfrom <= l + 1)) { /* can connect both? */ ------------------ | Branch (138:10): [True: 0, False: 0] | Branch (138:27): [True: 0, False: 0] ------------------ 139| 279| if (pfrom < from) from = pfrom; /* from = min(from, pfrom) */ ------------------ | Branch (139:11): [True: 277, False: 2] ------------------ 140| 279| if (pl > l) l = pl; /* l = max(l, pl) */ ------------------ | Branch (140:11): [True: 0, False: 279] ------------------ 141| 279| SETARG_A(*previous, from); ------------------ | | 126| 279|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 279|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 279|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 279|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 279| ((cast(Instruction, v)<lasttarget = fs->pc; 234| 14.3M| return fs->pc; 235| 14.3M|} luaK_patchlist: 306| 3.67M|void luaK_patchlist (FuncState *fs, int list, int target) { 307| 3.67M| lua_assert(target <= fs->pc); ------------------ | | 114| 3.67M|#define lua_assert(c) ((void)0) ------------------ 308| 3.67M| patchlistaux(fs, list, target, NO_REG, target); ------------------ | | 182| 3.67M|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 3.67M|#define MAXARG_A ((1<f; 384| | /* put new instruction in code array */ 385| 32.8M| luaM_growvector(fs->ls->L, f->code, fs->pc, f->sizecode, Instruction, ------------------ | | 67| 32.8M| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 65.6M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 32.8M| luaM_limitN(limit,t),e))) ------------------ 386| 32.8M| MAX_INT, "opcodes"); 387| 32.8M| f->code[fs->pc++] = i; 388| 32.8M| savelineinfo(fs, f, fs->ls->lastline); 389| 32.8M| return fs->pc - 1; /* index of new instruction */ 390| 32.8M|} luaK_codeABCk: 397| 27.3M|int luaK_codeABCk (FuncState *fs, OpCode o, int a, int b, int c, int k) { 398| 27.3M| lua_assert(getOpMode(o) == iABC); ------------------ | | 114| 27.3M|#define lua_assert(c) ((void)0) ------------------ 399| 27.3M| lua_assert(a <= MAXARG_A && b <= MAXARG_B && ------------------ | | 114| 27.3M|#define lua_assert(c) ((void)0) ------------------ 400| 27.3M| c <= MAXARG_C && (k & ~1) == 0); 401| 27.3M| return luaK_code(fs, CREATE_ABCk(o, a, b, c, k)); ------------------ | | 156| 27.3M|#define CREATE_ABCk(o,a,b,c,k) ((cast(Instruction, o)<>1) /* 'sBx' is signed */ | | ------------------ | | | | 72| 48.3k|#define MAXARG_Bx ((1<freereg + n; 468| 18.2M| if (newstack > fs->f->maxstacksize) { ------------------ | Branch (468:7): [True: 9.30k, False: 18.2M] ------------------ 469| 9.30k| if (newstack >= MAXREGS) ------------------ | | 35| 9.30k|#define MAXREGS 255 ------------------ | Branch (469:9): [True: 0, False: 9.30k] ------------------ 470| 0| luaX_syntaxerror(fs->ls, 471| 0| "function or expression needs too many registers"); 472| 9.30k| fs->f->maxstacksize = cast_byte(newstack); ------------------ | | 143| 9.30k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 9.30k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 473| 9.30k| } 474| 18.2M|} luaK_reserveregs: 480| 18.2M|void luaK_reserveregs (FuncState *fs, int n) { 481| 18.2M| luaK_checkstack(fs, n); 482| 18.2M| fs->freereg += n; 483| 18.2M|} luaK_int: 672| 38.1k|void luaK_int (FuncState *fs, int reg, lua_Integer i) { 673| 38.1k| if (fitsBx(i)) ------------------ | Branch (673:7): [True: 34.7k, False: 3.40k] ------------------ 674| 34.7k| luaK_codeAsBx(fs, OP_LOADI, reg, cast_int(i)); ------------------ | | 141| 34.7k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 34.7k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 675| 3.40k| else 676| 3.40k| luaK_codek(fs, reg, luaK_intK(fs, i)); 677| 38.1k|} luaK_setreturns: 721| 1.50k|void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) { 722| 1.50k| Instruction *pc = &getinstruction(fs, e); ------------------ | | 55| 1.50k|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 723| 1.50k| if (e->k == VCALL) /* expression is an open function call? */ ------------------ | Branch (723:7): [True: 1.34k, False: 160] ------------------ 724| 1.50k| SETARG_C(*pc, nresults + 1); ------------------ | | 134| 1.34k|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 1.34k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 1.34k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 1.34k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 1.34k| ((cast(Instruction, v)<k == VVARARG); ------------------ | | 114| 160|#define lua_assert(c) ((void)0) ------------------ 727| 160| SETARG_C(*pc, nresults + 1); ------------------ | | 134| 160|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 160|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 160|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 160|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 160| ((cast(Instruction, v)<freereg); ------------------ | | 126| 160|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 160|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 160|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 160|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 160| ((cast(Instruction, v)<k == VCALL) { /* expression is an open function call? */ ------------------ | Branch (755:7): [True: 207k, False: 12.4k] ------------------ 756| | /* already returns 1 value */ 757| 207k| lua_assert(GETARG_C(getinstruction(fs, e)) == 2); ------------------ | | 114| 207k|#define lua_assert(c) ((void)0) ------------------ 758| 207k| e->k = VNONRELOC; /* result has fixed position */ 759| 207k| e->u.info = GETARG_A(getinstruction(fs, e)); ------------------ | | 125| 207k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 207k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 207k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 207k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 760| 207k| } 761| 12.4k| else if (e->k == VVARARG) { ------------------ | Branch (761:12): [True: 146, False: 12.3k] ------------------ 762| 146| SETARG_C(getinstruction(fs, e), 2); ------------------ | | 134| 146|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 146|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 146|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 146|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 146| ((cast(Instruction, v)<k = VRELOC; /* can relocate its simple result */ 764| 146| } 765| 219k|} luaK_dischargevars: 772| 76.8M|void luaK_dischargevars (FuncState *fs, expdesc *e) { 773| 76.8M| switch (e->k) { 774| 886k| case VCONST: { ------------------ | Branch (774:5): [True: 886k, False: 75.9M] ------------------ 775| 886k| const2exp(const2val(fs, e), e); 776| 886k| break; 777| 0| } 778| 240k| case VLOCAL: { /* already in a register */ ------------------ | Branch (778:5): [True: 240k, False: 76.5M] ------------------ 779| 240k| e->u.info = e->u.var.ridx; 780| 240k| e->k = VNONRELOC; /* becomes a non-relocatable value */ 781| 240k| break; 782| 0| } 783| 1.42M| case VUPVAL: { /* move value to some (pending) register */ ------------------ | Branch (783:5): [True: 1.42M, False: 75.3M] ------------------ 784| 1.42M| e->u.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.info, 0); ------------------ | | 48| 1.42M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 785| 1.42M| e->k = VRELOC; 786| 1.42M| break; 787| 0| } 788| 4.56M| case VINDEXUP: { ------------------ | Branch (788:5): [True: 4.56M, False: 72.2M] ------------------ 789| 4.56M| e->u.info = luaK_codeABC(fs, OP_GETTABUP, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 4.56M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 790| 4.56M| e->k = VRELOC; 791| 4.56M| break; 792| 0| } 793| 619| case VINDEXI: { ------------------ | Branch (793:5): [True: 619, False: 76.8M] ------------------ 794| 619| freereg(fs, e->u.ind.t); 795| 619| e->u.info = luaK_codeABC(fs, OP_GETI, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 619|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 796| 619| e->k = VRELOC; 797| 619| break; 798| 0| } 799| 970k| case VINDEXSTR: { ------------------ | Branch (799:5): [True: 970k, False: 75.8M] ------------------ 800| 970k| freereg(fs, e->u.ind.t); 801| 970k| e->u.info = luaK_codeABC(fs, OP_GETFIELD, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 970k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 802| 970k| e->k = VRELOC; 803| 970k| break; 804| 0| } 805| 1.43M| case VINDEXED: { ------------------ | Branch (805:5): [True: 1.43M, False: 75.3M] ------------------ 806| 1.43M| freeregs(fs, e->u.ind.t, e->u.ind.idx); 807| 1.43M| e->u.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.ind.t, e->u.ind.idx); ------------------ | | 48| 1.43M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 808| 1.43M| e->k = VRELOC; 809| 1.43M| break; 810| 0| } 811| 207k| case VVARARG: case VCALL: { ------------------ | Branch (811:5): [True: 146, False: 76.8M] | Branch (811:19): [True: 207k, False: 76.6M] ------------------ 812| 207k| luaK_setoneret(fs, e); 813| 207k| break; 814| 146| } 815| 67.0M| default: break; /* there is one value available (somewhere) */ ------------------ | Branch (815:5): [True: 67.0M, False: 9.72M] ------------------ 816| 76.8M| } 817| 76.8M|} luaK_exp2nextreg: 942| 18.2M|void luaK_exp2nextreg (FuncState *fs, expdesc *e) { 943| 18.2M| luaK_dischargevars(fs, e); 944| 18.2M| freeexp(fs, e); 945| 18.2M| luaK_reserveregs(fs, 1); 946| 18.2M| exp2reg(fs, e, fs->freereg - 1); 947| 18.2M|} luaK_exp2anyreg: 954| 25.2M|int luaK_exp2anyreg (FuncState *fs, expdesc *e) { 955| 25.2M| luaK_dischargevars(fs, e); 956| 25.2M| if (e->k == VNONRELOC) { /* expression already has a register? */ ------------------ | Branch (956:7): [True: 7.42M, False: 17.8M] ------------------ 957| 7.42M| if (!hasjumps(e)) /* no jumps? */ ------------------ | | 38| 7.42M|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (957:9): [True: 7.41M, False: 8.77k] ------------------ 958| 7.41M| return e->u.info; /* result is already in a register */ 959| 8.77k| if (e->u.info >= luaY_nvarstack(fs)) { /* reg. is not a local? */ ------------------ | Branch (959:9): [True: 8.10k, False: 671] ------------------ 960| 8.10k| exp2reg(fs, e, e->u.info); /* put final result in it */ 961| 8.10k| return e->u.info; 962| 8.10k| } 963| | /* else expression has jumps and cannot change its register 964| | to hold the jump values, because it is a local variable. 965| | Go through to the default case. */ 966| 8.77k| } 967| 17.8M| luaK_exp2nextreg(fs, e); /* default: use next available register */ 968| 17.8M| return e->u.info; 969| 25.2M|} luaK_exp2anyregup: 976| 6.99M|void luaK_exp2anyregup (FuncState *fs, expdesc *e) { 977| 6.99M| if (e->k != VUPVAL || hasjumps(e)) ------------------ | | 38| 5.98M|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 0, False: 5.98M] | | ------------------ ------------------ | Branch (977:7): [True: 1.00M, False: 5.98M] ------------------ 978| 1.00M| luaK_exp2anyreg(fs, e); 979| 6.99M|} luaK_exp2val: 986| 12.1k|void luaK_exp2val (FuncState *fs, expdesc *e) { 987| 12.1k| if (hasjumps(e)) ------------------ | | 38| 12.1k|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 3, False: 12.1k] | | ------------------ ------------------ 988| 3| luaK_exp2anyreg(fs, e); 989| 12.1k| else 990| 12.1k| luaK_dischargevars(fs, e); 991| 12.1k|} luaK_exp2RK: 1028| 25.6k|int luaK_exp2RK (FuncState *fs, expdesc *e) { 1029| 25.6k| if (luaK_exp2K(fs, e)) ------------------ | Branch (1029:7): [True: 2.34k, False: 23.3k] ------------------ 1030| 2.34k| return 1; 1031| 23.3k| else { /* not a constant in the right range: put it in a register */ 1032| 23.3k| luaK_exp2anyreg(fs, e); 1033| 23.3k| return 0; 1034| 23.3k| } 1035| 25.6k|} luaK_storevar: 1048| 27.3k|void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) { 1049| 27.3k| switch (var->k) { 1050| 4.66k| case VLOCAL: { ------------------ | Branch (1050:5): [True: 4.66k, False: 22.7k] ------------------ 1051| 4.66k| freeexp(fs, ex); 1052| 4.66k| exp2reg(fs, ex, var->u.var.ridx); /* compute 'ex' into proper place */ 1053| 4.66k| return; 1054| 0| } 1055| 1.85k| case VUPVAL: { ------------------ | Branch (1055:5): [True: 1.85k, False: 25.5k] ------------------ 1056| 1.85k| int e = luaK_exp2anyreg(fs, ex); 1057| 1.85k| luaK_codeABC(fs, OP_SETUPVAL, e, var->u.info, 0); ------------------ | | 48| 1.85k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1058| 1.85k| break; 1059| 0| } 1060| 6.37k| case VINDEXUP: { ------------------ | Branch (1060:5): [True: 6.37k, False: 21.0k] ------------------ 1061| 6.37k| codeABRK(fs, OP_SETTABUP, var->u.ind.t, var->u.ind.idx, ex); 1062| 6.37k| break; 1063| 0| } 1064| 1.19k| case VINDEXI: { ------------------ | Branch (1064:5): [True: 1.19k, False: 26.1k] ------------------ 1065| 1.19k| codeABRK(fs, OP_SETI, var->u.ind.t, var->u.ind.idx, ex); 1066| 1.19k| break; 1067| 0| } 1068| 11.3k| case VINDEXSTR: { ------------------ | Branch (1068:5): [True: 11.3k, False: 16.0k] ------------------ 1069| 11.3k| codeABRK(fs, OP_SETFIELD, var->u.ind.t, var->u.ind.idx, ex); 1070| 11.3k| break; 1071| 0| } 1072| 1.94k| case VINDEXED: { ------------------ | Branch (1072:5): [True: 1.94k, False: 25.4k] ------------------ 1073| 1.94k| codeABRK(fs, OP_SETTABLE, var->u.ind.t, var->u.ind.idx, ex); 1074| 1.94k| break; 1075| 0| } 1076| 0| default: lua_assert(0); /* invalid var kind to store */ ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (1076:5): [True: 0, False: 27.3k] ------------------ 1077| 27.3k| } 1078| 22.7k| freeexp(fs, ex); 1079| 22.7k|} luaK_self: 1085| 221|void luaK_self (FuncState *fs, expdesc *e, expdesc *key) { 1086| 221| int ereg; 1087| 221| luaK_exp2anyreg(fs, e); 1088| 221| ereg = e->u.info; /* register where 'e' was placed */ 1089| 221| freeexp(fs, e); 1090| 221| e->u.info = fs->freereg; /* base register for op_self */ 1091| 221| e->k = VNONRELOC; /* self expression has a fixed register */ 1092| 221| luaK_reserveregs(fs, 2); /* function and 'self' produced by op_self */ 1093| 221| codeABRK(fs, OP_SELF, e->u.info, ereg, key); 1094| 221| freeexp(fs, key); 1095| 221|} luaK_goiftrue: 1133| 16.1k|void luaK_goiftrue (FuncState *fs, expdesc *e) { 1134| 16.1k| int pc; /* pc of new jump */ 1135| 16.1k| luaK_dischargevars(fs, e); 1136| 16.1k| switch (e->k) { 1137| 4.33k| case VJMP: { /* condition? */ ------------------ | Branch (1137:5): [True: 4.33k, False: 11.8k] ------------------ 1138| 4.33k| negatecondition(fs, e); /* jump when it is false */ 1139| 4.33k| pc = e->u.info; /* save jump position */ 1140| 4.33k| break; 1141| 0| } 1142| 891| case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: { ------------------ | Branch (1142:5): [True: 0, False: 16.1k] | Branch (1142:14): [True: 104, False: 16.0k] | Branch (1142:26): [True: 150, False: 15.9k] | Branch (1142:38): [True: 13, False: 16.1k] | Branch (1142:50): [True: 624, False: 15.5k] ------------------ 1143| 891| pc = NO_JUMP; /* always true; do nothing */ ------------------ | | 20| 891|#define NO_JUMP (-1) ------------------ 1144| 891| break; 1145| 267| } 1146| 10.9k| default: { ------------------ | Branch (1146:5): [True: 10.9k, False: 5.22k] ------------------ 1147| 10.9k| pc = jumponcond(fs, e, 0); /* jump when false */ 1148| 10.9k| break; 1149| 267| } 1150| 16.1k| } 1151| 16.1k| luaK_concat(fs, &e->f, pc); /* insert new jump in false list */ 1152| 16.1k| luaK_patchtohere(fs, e->t); /* true list jumps to here (to go through) */ 1153| 16.1k| e->t = NO_JUMP; ------------------ | | 20| 16.1k|#define NO_JUMP (-1) ------------------ 1154| 16.1k|} luaK_goiffalse: 1160| 114k|void luaK_goiffalse (FuncState *fs, expdesc *e) { 1161| 114k| int pc; /* pc of new jump */ 1162| 114k| luaK_dischargevars(fs, e); 1163| 114k| switch (e->k) { 1164| 99.9k| case VJMP: { ------------------ | Branch (1164:5): [True: 99.9k, False: 14.2k] ------------------ 1165| 99.9k| pc = e->u.info; /* already jump if true */ 1166| 99.9k| break; 1167| 0| } 1168| 7| case VNIL: case VFALSE: { ------------------ | Branch (1168:5): [True: 0, False: 114k] | Branch (1168:16): [True: 7, False: 114k] ------------------ 1169| 7| pc = NO_JUMP; /* always false; do nothing */ ------------------ | | 20| 7|#define NO_JUMP (-1) ------------------ 1170| 7| break; 1171| 0| } 1172| 14.2k| default: { ------------------ | Branch (1172:5): [True: 14.2k, False: 99.9k] ------------------ 1173| 14.2k| pc = jumponcond(fs, e, 1); /* jump if true */ 1174| 14.2k| break; 1175| 0| } 1176| 114k| } 1177| 114k| luaK_concat(fs, &e->t, pc); /* insert new jump in 't' list */ 1178| 114k| luaK_patchtohere(fs, e->f); /* false list jumps to here (to go through) */ 1179| 114k| e->f = NO_JUMP; ------------------ | | 20| 114k|#define NO_JUMP (-1) ------------------ 1180| 114k|} luaK_isKint: 1228| 1.87M|int luaK_isKint (expdesc *e) { 1229| 1.87M| return (e->k == VKINT && !hasjumps(e)); ------------------ | | 38| 26.1k|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (1229:11): [True: 26.1k, False: 1.85M] | Branch (1229:28): [True: 24.3k, False: 1.80k] ------------------ 1230| 1.87M|} luaK_indexed: 1278| 6.99M|void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) { 1279| 6.99M| if (k->k == VKSTR) ------------------ | Branch (1279:7): [True: 6.98M, False: 12.1k] ------------------ 1280| 6.98M| str2K(fs, k); 1281| 6.99M| lua_assert(!hasjumps(t) && ------------------ | | 114| 6.99M|#define lua_assert(c) ((void)0) ------------------ 1282| 6.99M| (t->k == VLOCAL || t->k == VNONRELOC || t->k == VUPVAL)); 1283| 6.99M| if (t->k == VUPVAL && !isKstr(fs, k)) /* upvalue indexed by non 'Kstr'? */ ------------------ | Branch (1283:7): [True: 5.98M, False: 1.00M] | Branch (1283:25): [True: 1.41M, False: 4.57M] ------------------ 1284| 1.41M| luaK_exp2anyreg(fs, t); /* put it in a register */ 1285| 6.99M| if (t->k == VUPVAL) { ------------------ | Branch (1285:7): [True: 4.57M, False: 2.42M] ------------------ 1286| 4.57M| t->u.ind.t = t->u.info; /* upvalue index */ 1287| 4.57M| t->u.ind.idx = k->u.info; /* literal string */ 1288| 4.57M| t->k = VINDEXUP; 1289| 4.57M| } 1290| 2.42M| else { 1291| | /* register index of the table */ 1292| 2.42M| t->u.ind.t = (t->k == VLOCAL) ? t->u.var.ridx: t->u.info; ------------------ | Branch (1292:18): [True: 0, False: 2.42M] ------------------ 1293| 2.42M| if (isKstr(fs, k)) { ------------------ | Branch (1293:9): [True: 981k, False: 1.44M] ------------------ 1294| 981k| t->u.ind.idx = k->u.info; /* literal string */ 1295| 981k| t->k = VINDEXSTR; 1296| 981k| } 1297| 1.44M| else if (isCint(k)) { ------------------ | Branch (1297:14): [True: 1.81k, False: 1.43M] ------------------ 1298| 1.81k| t->u.ind.idx = cast_int(k->u.ival); /* int. constant in proper range */ ------------------ | | 141| 1.81k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 1.81k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1299| 1.81k| t->k = VINDEXI; 1300| 1.81k| } 1301| 1.43M| else { 1302| 1.43M| t->u.ind.idx = luaK_exp2anyreg(fs, k); /* register */ 1303| 1.43M| t->k = VINDEXED; 1304| 1.43M| } 1305| 2.42M| } 1306| 6.99M|} luaK_prefix: 1612| 197k|void luaK_prefix (FuncState *fs, UnOpr opr, expdesc *e, int line) { 1613| 197k| static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP}; ------------------ | | 20| 197k|#define NO_JUMP (-1) ------------------ static const expdesc ef = {VKINT, {0}, NO_JUMP, NO_JUMP}; ------------------ | | 20| 197k|#define NO_JUMP (-1) ------------------ 1614| 197k| luaK_dischargevars(fs, e); 1615| 197k| switch (opr) { 1616| 171k| case OPR_MINUS: case OPR_BNOT: /* use 'ef' as fake 2nd operand */ ------------------ | Branch (1616:5): [True: 98.7k, False: 98.4k] | Branch (1616:21): [True: 72.3k, False: 124k] ------------------ 1617| 171k| if (constfolding(fs, opr + LUA_OPUNM, e, &ef)) ------------------ | | 227| 171k|#define LUA_OPUNM 12 ------------------ | Branch (1617:11): [True: 33.8k, False: 137k] ------------------ 1618| 33.8k| break; 1619| | /* else */ /* FALLTHROUGH */ 1620| 157k| case OPR_LEN: ------------------ | Branch (1620:5): [True: 19.9k, False: 177k] ------------------ 1621| 157k| codeunexpval(fs, unopr2op(opr), e, line); 1622| 157k| break; 1623| 6.12k| case OPR_NOT: codenot(fs, e); break; ------------------ | Branch (1623:5): [True: 6.12k, False: 191k] ------------------ 1624| 0| default: lua_assert(0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (1624:5): [True: 0, False: 197k] ------------------ 1625| 197k| } 1626| 197k|} luaK_infix: 1633| 7.31M|void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) { 1634| 7.31M| luaK_dischargevars(fs, v); 1635| 7.31M| switch (op) { 1636| 15.6k| case OPR_AND: { ------------------ | Branch (1636:5): [True: 15.6k, False: 7.29M] ------------------ 1637| 15.6k| luaK_goiftrue(fs, v); /* go ahead only if 'v' is true */ 1638| 15.6k| break; 1639| 0| } 1640| 113k| case OPR_OR: { ------------------ | Branch (1640:5): [True: 113k, False: 7.19M] ------------------ 1641| 113k| luaK_goiffalse(fs, v); /* go ahead only if 'v' is false */ 1642| 113k| break; 1643| 0| } 1644| 6.38k| case OPR_CONCAT: { ------------------ | Branch (1644:5): [True: 6.38k, False: 7.30M] ------------------ 1645| 6.38k| luaK_exp2nextreg(fs, v); /* operand must be on the stack */ 1646| 6.38k| break; 1647| 0| } 1648| 36.7k| case OPR_ADD: case OPR_SUB: ------------------ | Branch (1648:5): [True: 3.41k, False: 7.30M] | Branch (1648:19): [True: 33.3k, False: 7.27M] ------------------ 1649| 2.96M| case OPR_MUL: case OPR_DIV: case OPR_IDIV: ------------------ | Branch (1649:5): [True: 21.2k, False: 7.29M] | Branch (1649:19): [True: 2.88M, False: 4.42M] | Branch (1649:33): [True: 19.0k, False: 7.29M] ------------------ 1650| 3.28M| case OPR_MOD: case OPR_POW: ------------------ | Branch (1650:5): [True: 16.9k, False: 7.29M] | Branch (1650:19): [True: 304k, False: 7.00M] ------------------ 1651| 3.33M| case OPR_BAND: case OPR_BOR: case OPR_BXOR: ------------------ | Branch (1651:5): [True: 11.7k, False: 7.30M] | Branch (1651:20): [True: 1.21k, False: 7.31M] | Branch (1651:34): [True: 34.4k, False: 7.27M] ------------------ 1652| 3.54M| case OPR_SHL: case OPR_SHR: { ------------------ | Branch (1652:5): [True: 204k, False: 7.10M] | Branch (1652:19): [True: 2.01k, False: 7.31M] ------------------ 1653| 3.54M| if (!tonumeral(v, NULL)) ------------------ | Branch (1653:11): [True: 3.43M, False: 104k] ------------------ 1654| 3.43M| luaK_exp2anyreg(fs, v); 1655| | /* else keep numeral, which may be folded or used as an immediate 1656| | operand */ 1657| 3.54M| break; 1658| 3.53M| } 1659| 3.87k| case OPR_EQ: case OPR_NE: { ------------------ | Branch (1659:5): [True: 1.41k, False: 7.31M] | Branch (1659:18): [True: 2.45k, False: 7.31M] ------------------ 1660| 3.87k| if (!tonumeral(v, NULL)) ------------------ | Branch (1660:11): [True: 2.63k, False: 1.23k] ------------------ 1661| 2.63k| luaK_exp2RK(fs, v); 1662| | /* else keep numeral, which may be an immediate operand */ 1663| 3.87k| break; 1664| 1.41k| } 1665| 3.59M| case OPR_LT: case OPR_LE: ------------------ | Branch (1665:5): [True: 3.59M, False: 3.72M] | Branch (1665:18): [True: 5.67k, False: 7.30M] ------------------ 1666| 3.63M| case OPR_GT: case OPR_GE: { ------------------ | Branch (1666:5): [True: 34.9k, False: 7.27M] | Branch (1666:18): [True: 504, False: 7.31M] ------------------ 1667| 3.63M| int dummy, dummy2; 1668| 3.63M| if (!isSCnumber(v, &dummy, &dummy2)) ------------------ | Branch (1668:11): [True: 3.62M, False: 6.27k] ------------------ 1669| 3.62M| luaK_exp2anyreg(fs, v); 1670| | /* else keep numeral, which may be an immediate operand */ 1671| 3.63M| break; 1672| 3.63M| } 1673| 0| default: lua_assert(0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (1673:5): [True: 0, False: 7.31M] ------------------ 1674| 7.31M| } 1675| 7.31M|} luaK_posfix: 1703| 7.30M| expdesc *e1, expdesc *e2, int line) { 1704| 7.30M| luaK_dischargevars(fs, e2); 1705| 7.30M| if (foldbinop(opr) && constfolding(fs, opr + LUA_OPADD, e1, e2)) ------------------ | | 45| 14.6M|#define foldbinop(op) ((op) <= OPR_SHR) | | ------------------ | | | Branch (45:23): [True: 3.54M, False: 3.76M] | | ------------------ ------------------ if (foldbinop(opr) && constfolding(fs, opr + LUA_OPADD, e1, e2)) ------------------ | | 215| 3.54M|#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ ------------------ | Branch (1705:25): [True: 72.1k, False: 3.46M] ------------------ 1706| 72.1k| return; /* done by folding */ 1707| 7.23M| switch (opr) { 1708| 14.7k| case OPR_AND: { ------------------ | Branch (1708:5): [True: 14.7k, False: 7.22M] ------------------ 1709| 14.7k| lua_assert(e1->t == NO_JUMP); /* list closed by 'luaK_infix' */ ------------------ | | 114| 14.7k|#define lua_assert(c) ((void)0) ------------------ 1710| 14.7k| luaK_concat(fs, &e2->f, e1->f); 1711| 14.7k| *e1 = *e2; 1712| 14.7k| break; 1713| 0| } 1714| 112k| case OPR_OR: { ------------------ | Branch (1714:5): [True: 112k, False: 7.12M] ------------------ 1715| 112k| lua_assert(e1->f == NO_JUMP); /* list closed by 'luaK_infix' */ ------------------ | | 114| 112k|#define lua_assert(c) ((void)0) ------------------ 1716| 112k| luaK_concat(fs, &e2->t, e1->t); 1717| 112k| *e1 = *e2; 1718| 112k| break; 1719| 0| } 1720| 6.33k| case OPR_CONCAT: { /* e1 .. e2 */ ------------------ | Branch (1720:5): [True: 6.33k, False: 7.23M] ------------------ 1721| 6.33k| luaK_exp2nextreg(fs, e2); 1722| 6.33k| codeconcat(fs, e1, e2, line); 1723| 6.33k| break; 1724| 0| } 1725| 18.8k| case OPR_ADD: case OPR_MUL: { ------------------ | Branch (1725:5): [True: 2.73k, False: 7.23M] | Branch (1725:19): [True: 16.1k, False: 7.22M] ------------------ 1726| 18.8k| codecommutative(fs, opr, e1, e2, line); 1727| 18.8k| break; 1728| 2.73k| } 1729| 27.0k| case OPR_SUB: { ------------------ | Branch (1729:5): [True: 27.0k, False: 7.21M] ------------------ 1730| 27.0k| if (finishbinexpneg(fs, e1, e2, OP_ADDI, line, TM_SUB)) ------------------ | Branch (1730:11): [True: 13.2k, False: 13.8k] ------------------ 1731| 13.2k| break; /* coded as (r1 + -I) */ 1732| | /* ELSE */ 1733| 27.0k| } /* FALLTHROUGH */ 1734| 3.18M| case OPR_DIV: case OPR_IDIV: case OPR_MOD: case OPR_POW: { ------------------ | Branch (1734:5): [True: 2.88M, False: 4.34M] | Branch (1734:19): [True: 19.0k, False: 7.21M] | Branch (1734:34): [True: 11.3k, False: 7.22M] | Branch (1734:48): [True: 252k, False: 6.98M] ------------------ 1735| 3.18M| codearith(fs, opr, e1, e2, 0, line); 1736| 3.18M| break; 1737| 2.93M| } 1738| 44.8k| case OPR_BAND: case OPR_BOR: case OPR_BXOR: { ------------------ | Branch (1738:5): [True: 10.6k, False: 7.22M] | Branch (1738:20): [True: 1.16k, False: 7.23M] | Branch (1738:34): [True: 33.1k, False: 7.20M] ------------------ 1739| 44.8k| codebitwise(fs, opr, e1, e2, line); 1740| 44.8k| break; 1741| 11.7k| } 1742| 204k| case OPR_SHL: { ------------------ | Branch (1742:5): [True: 204k, False: 7.03M] ------------------ 1743| 204k| if (isSCint(e1)) { ------------------ | Branch (1743:11): [True: 4.37k, False: 200k] ------------------ 1744| 4.37k| swapexps(e1, e2); 1745| 4.37k| codebini(fs, OP_SHLI, e1, e2, 1, line, TM_SHL); /* I << r2 */ 1746| 4.37k| } 1747| 200k| else if (finishbinexpneg(fs, e1, e2, OP_SHRI, line, TM_SHL)) { ------------------ | Branch (1747:16): [True: 2.25k, False: 198k] ------------------ 1748| 2.25k| /* coded as (r1 >> -I) */; 1749| 2.25k| } 1750| 198k| else /* regular case (two registers) */ 1751| 198k| codebinexpval(fs, opr, e1, e2, line); 1752| 204k| break; 1753| 11.7k| } 1754| 1.42k| case OPR_SHR: { ------------------ | Branch (1754:5): [True: 1.42k, False: 7.23M] ------------------ 1755| 1.42k| if (isSCint(e2)) ------------------ | Branch (1755:11): [True: 11, False: 1.41k] ------------------ 1756| 11| codebini(fs, OP_SHRI, e1, e2, 0, line, TM_SHR); /* r1 >> I */ 1757| 1.41k| else /* regular case (two registers) */ 1758| 1.41k| codebinexpval(fs, opr, e1, e2, line); 1759| 1.42k| break; 1760| 11.7k| } 1761| 3.75k| case OPR_EQ: case OPR_NE: { ------------------ | Branch (1761:5): [True: 1.39k, False: 7.23M] | Branch (1761:18): [True: 2.35k, False: 7.23M] ------------------ 1762| 3.75k| codeeq(fs, opr, e1, e2); 1763| 3.75k| break; 1764| 1.39k| } 1765| 34.9k| case OPR_GT: case OPR_GE: { ------------------ | Branch (1765:5): [True: 34.4k, False: 7.20M] | Branch (1765:18): [True: 504, False: 7.23M] ------------------ 1766| | /* '(a > b)' <=> '(b < a)'; '(a >= b)' <=> '(b <= a)' */ 1767| 34.9k| swapexps(e1, e2); 1768| 34.9k| opr = cast(BinOpr, (opr - OPR_GT) + OPR_LT); ------------------ | | 136| 34.9k|#define cast(t, exp) ((t)(exp)) ------------------ 1769| 34.9k| } /* FALLTHROUGH */ 1770| 3.63M| case OPR_LT: case OPR_LE: { ------------------ | Branch (1770:5): [True: 3.59M, False: 3.64M] | Branch (1770:18): [True: 5.51k, False: 7.23M] ------------------ 1771| 3.63M| codeorder(fs, opr, e1, e2); 1772| 3.63M| break; 1773| 3.62M| } 1774| 0| default: lua_assert(0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (1774:5): [True: 0, False: 7.23M] ------------------ 1775| 7.23M| } 1776| 7.23M|} luaK_fixline: 1783| 7.31M|void luaK_fixline (FuncState *fs, int line) { 1784| 7.31M| removelastlineinfo(fs); 1785| 7.31M| savelineinfo(fs, fs->f, line); 1786| 7.31M|} luaK_settablesize: 1789| 341|void luaK_settablesize (FuncState *fs, int pc, int ra, int asize, int hsize) { 1790| 341| Instruction *inst = &fs->f->code[pc]; 1791| 341| int rb = (hsize != 0) ? luaO_ceillog2(hsize) + 1 : 0; /* hash size */ ------------------ | Branch (1791:12): [True: 14, False: 327] ------------------ 1792| 341| int extra = asize / (MAXARG_C + 1); /* higher bits of array size */ ------------------ | | 97| 341|#define MAXARG_C ((1< 0); /* true iff needs extra argument */ 1795| 341| *inst = CREATE_ABCk(OP_NEWTABLE, ra, rb, rc, k); ------------------ | | 156| 341|#define CREATE_ABCk(o,a,b,c,k) ((cast(Instruction, o)<freereg = base + 1; /* free registers with list values */ 1820| 151|} luaK_finish: 1843| 3.93k|void luaK_finish (FuncState *fs) { 1844| 3.93k| int i; 1845| 3.93k| Proto *p = fs->f; 1846| 501k| for (i = 0; i < fs->pc; i++) { ------------------ | Branch (1846:15): [True: 497k, False: 3.93k] ------------------ 1847| 497k| Instruction *pc = &p->code[i]; 1848| 497k| lua_assert(i == 0 || isOT(*(pc - 1)) == isIT(*pc)); ------------------ | | 114| 497k|#define lua_assert(c) ((void)0) ------------------ 1849| 497k| switch (GET_OPCODE(*pc)) { ------------------ | | 114| 497k|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 497k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1850| 7.40k| case OP_RETURN0: case OP_RETURN1: { ------------------ | Branch (1850:7): [True: 3.93k, False: 493k] | Branch (1850:24): [True: 3.46k, False: 494k] ------------------ 1851| 7.40k| if (!(fs->needclose || p->is_vararg)) ------------------ | Branch (1851:15): [True: 211, False: 7.18k] | Branch (1851:32): [True: 50, False: 7.13k] ------------------ 1852| 7.13k| break; /* no extra work */ 1853| | /* else use OP_RETURN to do the extra work */ 1854| 261| SET_OPCODE(*pc, OP_RETURN); ------------------ | | 115| 261|#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ | | ------------------ | | | | 108| 261|#define MASK0(n,p) (~MASK1(n,p)) | | | | ------------------ | | | | | | 105| 261|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | ------------------ | | ------------------ | | 116| 261| ((cast(Instruction, o)<needclose) ------------------ | Branch (1857:13): [True: 211, False: 86] ------------------ 1858| 297| SETARG_k(*pc, 1); /* signal that it needs to close */ ------------------ | | 138| 211|#define SETARG_k(i,v) setarg(i, v, POS_k, 1) | | ------------------ | | | | 122| 211|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 211|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 211|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 211| ((cast(Instruction, v)<is_vararg) ------------------ | Branch (1859:13): [True: 55, False: 242] ------------------ 1860| 297| SETARG_C(*pc, p->numparams + 1); /* signal that it is vararg */ ------------------ | | 134| 55|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 55|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 55|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 55|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 55| ((cast(Instruction, v)<code, i); 1865| 41.9k| fixjump(fs, i, target); 1866| 41.9k| break; 1867| 281| } 1868| 448k| default: break; ------------------ | Branch (1868:7): [True: 448k, False: 49.3k] ------------------ 1869| 497k| } 1870| 497k| } 1871| 3.93k|} lcode.c:const2val: 74| 886k|static TValue *const2val (FuncState *fs, const expdesc *e) { 75| 886k| lua_assert(e->k == VCONST); ------------------ | | 114| 886k|#define lua_assert(c) ((void)0) ------------------ 76| 886k| return &fs->ls->dyd->actvar.arr[e->u.info].k; 77| 886k|} lcode.c:tonumeral: 56| 10.6M|static int tonumeral (const expdesc *e, TValue *v) { 57| 10.6M| if (hasjumps(e)) ------------------ | | 38| 10.6M|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 5.87k, False: 10.6M] | | ------------------ ------------------ 58| 5.87k| return 0; /* not a numeral */ 59| 10.6M| switch (e->k) { 60| 324k| case VKINT: ------------------ | Branch (60:5): [True: 324k, False: 10.2M] ------------------ 61| 324k| if (v) setivalue(v, e->u.ival); ------------------ | | 345| 214k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 214k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 214k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ | Branch (61:11): [True: 214k, False: 110k] ------------------ 62| 324k| return 1; 63| 94.7k| case VKFLT: ------------------ | Branch (63:5): [True: 94.7k, False: 10.5M] ------------------ 64| 94.7k| if (v) setfltvalue(v, e->u.nval); ------------------ | | 339| 50.6k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 50.6k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 50.6k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ | Branch (64:11): [True: 50.6k, False: 44.0k] ------------------ 65| 94.7k| return 1; 66| 10.1M| default: return 0; ------------------ | Branch (66:5): [True: 10.1M, False: 419k] ------------------ 67| 10.6M| } 68| 10.6M|} lcode.c:previousinstruction: 116| 722k|static Instruction *previousinstruction (FuncState *fs) { 117| 722k| static const Instruction invalidinstruction = ~(Instruction)0; 118| 722k| if (fs->pc > fs->lasttarget) ------------------ | Branch (118:7): [True: 418k, False: 303k] ------------------ 119| 418k| return &fs->f->code[fs->pc - 1]; /* previous instruction */ 120| 303k| else 121| 303k| return cast(Instruction*, &invalidinstruction); ------------------ | | 136| 303k|#define cast(t, exp) ((t)(exp)) ------------------ 122| 722k|} lcode.c:getjump: 154| 37.6M|static int getjump (FuncState *fs, int pc) { 155| 37.6M| int offset = GETARG_sJ(fs->f->code[pc]); ------------------ | | 151| 37.6M| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | ------------------ | | | | 115| 37.6M|#define check_exp(c,e) (e) | | ------------------ ------------------ 156| 37.6M| if (offset == NO_JUMP) /* point to itself represents end of list */ ------------------ | | 20| 37.6M|#define NO_JUMP (-1) ------------------ | Branch (156:7): [True: 3.68M, False: 33.9M] ------------------ 157| 3.68M| return NO_JUMP; /* end of list */ ------------------ | | 20| 3.68M|#define NO_JUMP (-1) ------------------ 158| 33.9M| else 159| 33.9M| return (pc+1)+offset; /* turn offset into absolute position */ 160| 37.6M|} lcode.c:fixjump: 167| 3.80M|static void fixjump (FuncState *fs, int pc, int dest) { 168| 3.80M| Instruction *jmp = &fs->f->code[pc]; 169| 3.80M| int offset = dest - (pc + 1); 170| 3.80M| lua_assert(dest != NO_JUMP); ------------------ | | 114| 3.80M|#define lua_assert(c) ((void)0) ------------------ 171| 3.80M| if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) ------------------ | | 92| 3.80M|#define OFFSET_sJ (MAXARG_sJ >> 1) | | ------------------ | | | | 87| 3.80M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | | | ------------------ | | | | | | 43| 3.80M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 40| 3.80M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 38| 3.80M|#define SIZE_C 8 | | | | | | | | ------------------ | | | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 39| 3.80M|#define SIZE_B 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 41| 3.80M|#define SIZE_A 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) ------------------ | | 87| 3.80M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | ------------------ | | | | 43| 3.80M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | ------------------ | | | | | | 40| 3.80M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | ------------------ | | | | | | | | 38| 3.80M|#define SIZE_C 8 | | | | | | ------------------ | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | ------------------ | | | | | | | | 39| 3.80M|#define SIZE_B 8 | | | | | | ------------------ | | | | ------------------ | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | ------------------ | | | | | | 41| 3.80M|#define SIZE_A 8 | | | | ------------------ | | ------------------ ------------------ if (!(-OFFSET_sJ <= offset && offset <= MAXARG_sJ - OFFSET_sJ)) ------------------ | | 92| 3.80M|#define OFFSET_sJ (MAXARG_sJ >> 1) | | ------------------ | | | | 87| 3.80M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | | | ------------------ | | | | | | 43| 3.80M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 40| 3.80M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 38| 3.80M|#define SIZE_C 8 | | | | | | | | ------------------ | | | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 39| 3.80M|#define SIZE_B 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 41| 3.80M|#define SIZE_A 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (171:9): [True: 3.80M, False: 0] | Branch (171:33): [True: 3.80M, False: 0] ------------------ 172| 0| luaX_syntaxerror(fs->ls, "control structure too long"); 173| 3.80M| lua_assert(GET_OPCODE(*jmp) == OP_JMP); ------------------ | | 114| 3.80M|#define lua_assert(c) ((void)0) ------------------ 174| 3.80M| SETARG_sJ(*jmp, offset); ------------------ | | 153| 3.80M| setarg(i, cast_uint((j)+OFFSET_sJ), POS_sJ, SIZE_sJ) | | ------------------ | | | | 122| 3.80M|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 3.80M|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 3.80M|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 3.80M| ((cast(Instruction, v)<>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 3.72M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (261:7): [True: 3.70M, False: 22.6k] ------------------ 262| 3.70M| return 0; /* cannot patch other instructions */ 263| 22.6k| if (reg != NO_REG && reg != GETARG_B(*i)) ------------------ | | 182| 22.6k|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 45.2k|#define MAXARG_A ((1<f->code[pc]; 245| 7.28M| if (pc >= 1 && testTMode(GET_OPCODE(*(pi-1)))) ------------------ | | 385| 7.28M|#define testTMode(m) (luaP_opmodes[m] & (1 << 4)) | | ------------------ | | | Branch (385:22): [True: 7.27M, False: 12.3k] | | ------------------ ------------------ | Branch (245:7): [True: 7.28M, False: 0] ------------------ 246| 7.27M| return pi-1; 247| 12.3k| else 248| 12.3k| return pi; 249| 7.28M|} lcode.c:savelineinfo: 329| 40.1M|static void savelineinfo (FuncState *fs, Proto *f, int line) { 330| 40.1M| int linedif = line - fs->previousline; 331| 40.1M| int pc = fs->pc - 1; /* last instruction coded */ 332| 40.1M| if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) { ------------------ | | 319| 80.2M|#define LIMLINEDIFF 0x80 ------------------ if (abs(linedif) >= LIMLINEDIFF || fs->iwthabs++ >= MAXIWTHABS) { ------------------ | | 35| 39.9M|#define MAXIWTHABS 128 ------------------ | Branch (332:7): [True: 163k, False: 39.9M] | Branch (332:38): [True: 310k, False: 39.6M] ------------------ 333| 474k| luaM_growvector(fs->ls->L, f->abslineinfo, fs->nabslineinfo, ------------------ | | 67| 474k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 949k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 474k| luaM_limitN(limit,t),e))) ------------------ 334| 474k| f->sizeabslineinfo, AbsLineInfo, MAX_INT, "lines"); 335| 474k| f->abslineinfo[fs->nabslineinfo].pc = pc; 336| 474k| f->abslineinfo[fs->nabslineinfo++].line = line; 337| 474k| linedif = ABSLINEINFO; /* signal that there is absolute information */ ------------------ | | 27| 474k|#define ABSLINEINFO (-0x80) ------------------ 338| 474k| fs->iwthabs = 1; /* restart counter */ 339| 474k| } 340| 40.1M| luaM_growvector(fs->ls->L, f->lineinfo, pc, f->sizelineinfo, ls_byte, ------------------ | | 67| 40.1M| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 80.2M|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 40.1M| luaM_limitN(limit,t),e))) ------------------ 341| 40.1M| MAX_INT, "opcodes"); 342| 40.1M| f->lineinfo[pc] = linedif; 343| 40.1M| fs->previousline = line; /* last line saved */ 344| 40.1M|} lcode.c:codesJ: 429| 3.67M|static int codesJ (FuncState *fs, OpCode o, int sj, int k) { 430| 3.67M| unsigned int j = sj + OFFSET_sJ; ------------------ | | 92| 3.67M|#define OFFSET_sJ (MAXARG_sJ >> 1) | | ------------------ | | | | 87| 3.67M|#define MAXARG_sJ ((1 << SIZE_sJ) - 1) | | | | ------------------ | | | | | | 43| 3.67M|#define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 40| 3.67M|#define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 38| 3.67M|#define SIZE_C 8 | | | | | | | | ------------------ | | | | | | | | #define SIZE_Bx (SIZE_C + SIZE_B + 1) | | | | | | | | ------------------ | | | | | | | | | | 39| 3.67M|#define SIZE_B 8 | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define SIZE_sJ (SIZE_Bx + SIZE_A) | | | | | | ------------------ | | | | | | | | 41| 3.67M|#define SIZE_A 8 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 431| 3.67M| lua_assert(getOpMode(o) == isJ); ------------------ | | 114| 3.67M|#define lua_assert(c) ((void)0) ------------------ 432| 3.67M| lua_assert(j <= MAXARG_sJ && (k & ~1) == 0); ------------------ | | 114| 3.67M|#define lua_assert(c) ((void)0) ------------------ 433| 3.67M| return luaK_code(fs, CREATE_sJ(o, j, k)); ------------------ | | 169| 3.67M|#define CREATE_sJ(o,j,k) ((cast(Instruction, o) << POS_OP) \ | | ------------------ | | | | 136| 3.67M|#define cast(t, exp) ((t)(exp)) | | ------------------ | | #define CREATE_sJ(o,j,k) ((cast(Instruction, o) << POS_OP) \ | | ------------------ | | | | 47| 3.67M|#define POS_OP 0 | | ------------------ | | 170| 3.67M| | (cast(Instruction, j) << POS_sJ) \ | | ------------------ | | | | 136| 3.67M|#define cast(t, exp) ((t)(exp)) | | ------------------ | | | (cast(Instruction, j) << POS_sJ) \ | | ------------------ | | | | 58| 3.67M|#define POS_sJ POS_A | | | | ------------------ | | | | | | 49| 3.67M|#define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 47| 3.67M|#define POS_OP 0 | | | | | | ------------------ | | | | | | #define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 45| 3.67M|#define SIZE_OP 7 | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 171| 3.67M| | (cast(Instruction, k) << POS_k)) | | ------------------ | | | | 136| 3.67M|#define cast(t, exp) ((t)(exp)) | | ------------------ | | | (cast(Instruction, k) << POS_k)) | | ------------------ | | | | 50| 3.67M|#define POS_k (POS_A + SIZE_A) | | | | ------------------ | | | | | | 49| 3.67M|#define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 47| 3.67M|#define POS_OP 0 | | | | | | ------------------ | | | | | | #define POS_A (POS_OP + SIZE_OP) | | | | | | ------------------ | | | | | | | | 45| 3.67M|#define SIZE_OP 7 | | | | | | ------------------ | | | | ------------------ | | | | #define POS_k (POS_A + SIZE_A) | | | | ------------------ | | | | | | 41| 3.67M|#define SIZE_A 8 | | | | ------------------ | | ------------------ ------------------ 434| 3.67M|} lcode.c:fitsBx: 667| 56.4k|static int fitsBx (lua_Integer i) { 668| 56.4k| return (-OFFSET_sBx <= i && i <= MAXARG_Bx - OFFSET_sBx); ------------------ | | 77| 56.4k|#define OFFSET_sBx (MAXARG_Bx>>1) /* 'sBx' is signed */ | | ------------------ | | | | 72| 56.4k|#define MAXARG_Bx ((1<>1) /* 'sBx' is signed */ | | ------------------ | | | | 72| 55.9k|#define MAXARG_Bx ((1<value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 44.7k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 588| 44.7k| return addk(fs, &o, &o); /* use integer itself as key */ 589| 44.7k|} lcode.c:addk: 543| 7.30M|static int addk (FuncState *fs, TValue *key, TValue *v) { 544| 7.30M| TValue val; 545| 7.30M| lua_State *L = fs->ls->L; 546| 7.30M| Proto *f = fs->f; 547| 7.30M| const TValue *idx = luaH_get(fs->ls->h, key); /* query scanner table */ 548| 7.30M| int k, oldsize; 549| 7.30M| if (ttisinteger(idx)) { /* is there an index there? */ ------------------ | | 328| 7.30M|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 7.30M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 7.30M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 7.29M, False: 18.5k] | | | | ------------------ | | ------------------ ------------------ 550| 7.29M| k = cast_int(ivalue(idx)); ------------------ | | 141| 7.29M|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 7.29M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 551| | /* correct value? (warning: must distinguish floats from integers!) */ 552| 7.29M| if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) && ------------------ | | 84| 7.27M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 7.27M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ if (k < fs->nk && ttypetag(&f->k[k]) == ttypetag(v) && ------------------ | | 84| 7.27M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 14.5M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ | Branch (552:9): [True: 7.27M, False: 17.1k] | Branch (552:23): [True: 7.27M, False: 1.08k] ------------------ 553| 7.29M| luaV_rawequalobj(&f->k[k], v)) ------------------ | | 75| 7.27M|#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2) | | ------------------ | | | Branch (75:34): [True: 7.25M, False: 22.5k] | | ------------------ ------------------ 554| 7.25M| return k; /* reuse index */ 555| 7.29M| } 556| | /* constant not found; create a new entry */ 557| 59.2k| oldsize = f->sizek; 558| 59.2k| k = fs->nk; 559| | /* numerical value does not need GC barrier; 560| | table has no metatable, so it does not need to invalidate cache */ 561| 59.2k| setivalue(&val, k); ------------------ | | 345| 59.2k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 59.2k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 59.2k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 562| 59.2k| luaH_finishset(L, fs->ls->h, key, idx, &val); 563| 59.2k| luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants"); ------------------ | | 67| 59.2k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 118k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 59.2k| luaM_limitN(limit,t),e))) ------------------ 564| 145k| while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]); ------------------ | | 200| 86.5k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 145k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ | Branch (564:10): [True: 86.5k, False: 59.2k] ------------------ 565| 59.2k| setobj(L, &f->k[k], v); ------------------ | | 119| 59.2k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 59.2k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 59.2k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 59.2k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 59.2k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 59.2k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 59.2k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 59.2k|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 566| 59.2k| fs->nk++; 567| 59.2k| luaC_barrier(L, f, v); ------------------ | | 179| 59.2k|#define luaC_barrier(L,p,v) ( \ | | 180| 59.2k| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 59.2k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 59.2k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 59.2k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 33.7k, False: 25.4k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 33.7k|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 33.7k| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 33.7k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 33.7k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 67.5k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 33.7k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 177| 33.7k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 33.7k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 33.7k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 25.4k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 25.4k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 568| 59.2k| return k; 569| 7.30M|} lcode.c:const2exp: 692| 886k|static void const2exp (TValue *v, expdesc *e) { 693| 886k| switch (ttypetag(v)) { ------------------ | | 84| 886k|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 886k|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 694| 0| case LUA_VNUMINT: ------------------ | | 323| 0|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (694:5): [True: 0, False: 886k] ------------------ 695| 0| e->k = VKINT; e->u.ival = ivalue(v); ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 696| 0| break; 697| 0| case LUA_VNUMFLT: ------------------ | | 324| 0|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (697:5): [True: 0, False: 886k] ------------------ 698| 0| e->k = VKFLT; e->u.nval = fltvalue(v); ------------------ | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 699| 0| break; 700| 176k| case LUA_VFALSE: ------------------ | | 239| 176k|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 176k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (700:5): [True: 176k, False: 709k] ------------------ 701| 176k| e->k = VFALSE; 702| 176k| break; 703| 12| case LUA_VTRUE: ------------------ | | 240| 12|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 12|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (703:5): [True: 12, False: 886k] ------------------ 704| 12| e->k = VTRUE; 705| 12| break; 706| 665k| case LUA_VNIL: ------------------ | | 183| 665k|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 665k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (706:5): [True: 665k, False: 221k] ------------------ 707| 665k| e->k = VNIL; 708| 665k| break; 709| 44.2k| case LUA_VSHRSTR: case LUA_VLNGSTR: ------------------ | | 360| 44.2k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 44.2k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VSHRSTR: case LUA_VLNGSTR: ------------------ | | 361| 44.2k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 44.2k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (709:5): [True: 44.2k, False: 842k] | Branch (709:24): [True: 0, False: 886k] ------------------ 710| 44.2k| e->k = VKSTR; e->u.strval = tsvalue(v); ------------------ | | 369| 44.2k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 44.2k|#define check_exp(c,e) (e) | | ------------------ ------------------ 711| 44.2k| break; 712| 0| default: lua_assert(0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (712:5): [True: 0, False: 886k] ------------------ 713| 886k| } 714| 886k|} lcode.c:freereg: 491| 18.3M|static void freereg (FuncState *fs, int reg) { 492| 18.3M| if (reg >= luaY_nvarstack(fs)) { ------------------ | Branch (492:7): [True: 18.0M, False: 318k] ------------------ 493| 18.0M| fs->freereg--; 494| 18.0M| lua_assert(reg == fs->freereg); ------------------ | | 114| 18.0M|#define lua_assert(c) ((void)0) ------------------ 495| 18.0M| } 496| 18.3M|} lcode.c:freeregs: 502| 8.54M|static void freeregs (FuncState *fs, int r1, int r2) { 503| 8.54M| if (r1 > r2) { ------------------ | Branch (503:7): [True: 236k, False: 8.30M] ------------------ 504| 236k| freereg(fs, r1); 505| 236k| freereg(fs, r2); 506| 236k| } 507| 8.30M| else { 508| 8.30M| freereg(fs, r2); 509| 8.30M| freereg(fs, r1); 510| 8.30M| } 511| 8.54M|} lcode.c:freeexp: 517| 18.4M|static void freeexp (FuncState *fs, expdesc *e) { 518| 18.4M| if (e->k == VNONRELOC) ------------------ | Branch (518:7): [True: 321k, False: 18.1M] ------------------ 519| 321k| freereg(fs, e->u.info); 520| 18.4M|} lcode.c:exp2reg: 914| 18.2M|static void exp2reg (FuncState *fs, expdesc *e, int reg) { 915| 18.2M| discharge2reg(fs, e, reg); 916| 18.2M| if (e->k == VJMP) /* expression itself is a test? */ ------------------ | Branch (916:7): [True: 3.53M, False: 14.7M] ------------------ 917| 3.53M| luaK_concat(fs, &e->t, e->u.info); /* put this jump in 't' list */ 918| 18.2M| if (hasjumps(e)) { ------------------ | | 38| 18.2M|#define hasjumps(e) ((e)->t != (e)->f) | | ------------------ | | | Branch (38:21): [True: 3.55M, False: 14.7M] | | ------------------ ------------------ 919| 3.55M| int final; /* position after whole expression */ 920| 3.55M| int p_f = NO_JUMP; /* position of an eventual LOAD false */ ------------------ | | 20| 3.55M|#define NO_JUMP (-1) ------------------ 921| 3.55M| int p_t = NO_JUMP; /* position of an eventual LOAD true */ ------------------ | | 20| 3.55M|#define NO_JUMP (-1) ------------------ 922| 3.55M| if (need_value(fs, e->t) || need_value(fs, e->f)) { ------------------ | Branch (922:9): [True: 3.53M, False: 13.7k] | Branch (922:33): [True: 3.54k, False: 10.2k] ------------------ 923| 3.54M| int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs); ------------------ | | 20| 3.53M|#define NO_JUMP (-1) ------------------ | Branch (923:16): [True: 3.53M, False: 11.6k] ------------------ 924| 3.54M| p_f = code_loadbool(fs, reg, OP_LFALSESKIP); /* skip next inst. */ 925| 3.54M| p_t = code_loadbool(fs, reg, OP_LOADTRUE); 926| | /* jump around these booleans if 'e' is not a test */ 927| 3.54M| luaK_patchtohere(fs, fj); 928| 3.54M| } 929| 3.55M| final = luaK_getlabel(fs); 930| 3.55M| patchlistaux(fs, e->f, final, reg, p_f); 931| 3.55M| patchlistaux(fs, e->t, final, reg, p_t); 932| 3.55M| } 933| 18.2M| e->f = e->t = NO_JUMP; ------------------ | | 20| 18.2M|#define NO_JUMP (-1) ------------------ 934| 18.2M| e->u.info = reg; 935| 18.2M| e->k = VNONRELOC; 936| 18.2M|} lcode.c:discharge2reg: 825| 18.3M|static void discharge2reg (FuncState *fs, expdesc *e, int reg) { 826| 18.3M| luaK_dischargevars(fs, e); 827| 18.3M| switch (e->k) { 828| 715k| case VNIL: { ------------------ | Branch (828:5): [True: 715k, False: 17.5M] ------------------ 829| 715k| luaK_nil(fs, reg, 1); 830| 715k| break; 831| 0| } 832| 178k| case VFALSE: { ------------------ | Branch (832:5): [True: 178k, False: 18.1M] ------------------ 833| 178k| luaK_codeABC(fs, OP_LOADFALSE, reg, 0, 0); ------------------ | | 48| 178k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 834| 178k| break; 835| 0| } 836| 478| case VTRUE: { ------------------ | Branch (836:5): [True: 478, False: 18.3M] ------------------ 837| 478| luaK_codeABC(fs, OP_LOADTRUE, reg, 0, 0); ------------------ | | 48| 478|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 838| 478| break; 839| 0| } 840| 239k| case VKSTR: { ------------------ | Branch (840:5): [True: 239k, False: 18.0M] ------------------ 841| 239k| str2K(fs, e); 842| 239k| } /* FALLTHROUGH */ 843| 1.66M| case VK: { ------------------ | Branch (843:5): [True: 1.42M, False: 16.8M] ------------------ 844| 1.66M| luaK_codek(fs, reg, e->u.info); 845| 1.66M| break; 846| 239k| } 847| 30.0k| case VKFLT: { ------------------ | Branch (847:5): [True: 30.0k, False: 18.2M] ------------------ 848| 30.0k| luaK_float(fs, reg, e->u.nval); 849| 30.0k| break; 850| 239k| } 851| 37.6k| case VKINT: { ------------------ | Branch (851:5): [True: 37.6k, False: 18.2M] ------------------ 852| 37.6k| luaK_int(fs, reg, e->u.ival); 853| 37.6k| break; 854| 239k| } 855| 12.0M| case VRELOC: { ------------------ | Branch (855:5): [True: 12.0M, False: 6.27M] ------------------ 856| 12.0M| Instruction *pc = &getinstruction(fs, e); ------------------ | | 55| 12.0M|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 857| 12.0M| SETARG_A(*pc, reg); /* instruction will put result in 'reg' */ ------------------ | | 126| 12.0M|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 12.0M|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 12.0M|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 12.0M|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 12.0M| ((cast(Instruction, v)<u.info) ------------------ | Branch (861:11): [True: 8.16k, False: 106k] ------------------ 862| 8.16k| luaK_codeABC(fs, OP_MOVE, reg, e->u.info, 0); ------------------ | | 48| 8.16k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 863| 114k| break; 864| 239k| } 865| 3.53M| default: { ------------------ | Branch (865:5): [True: 3.53M, False: 14.7M] ------------------ 866| 3.53M| lua_assert(e->k == VJMP); ------------------ | | 114| 3.53M|#define lua_assert(c) ((void)0) ------------------ 867| 3.53M| return; /* nothing to do... */ 868| 239k| } 869| 18.3M| } 870| 14.7M| e->u.info = reg; 871| 14.7M| e->k = VNONRELOC; 872| 14.7M|} lcode.c:luaK_float: 680| 30.0k|static void luaK_float (FuncState *fs, int reg, lua_Number f) { 681| 30.0k| lua_Integer fi; 682| 30.0k| if (luaV_flttointeger(f, &fi, F2Ieq) && fitsBx(fi)) ------------------ | Branch (682:7): [True: 18.3k, False: 11.7k] | Branch (682:43): [True: 13.6k, False: 4.67k] ------------------ 683| 13.6k| luaK_codeAsBx(fs, OP_LOADF, reg, cast_int(fi)); ------------------ | | 141| 13.6k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 13.6k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 684| 16.3k| else 685| 16.3k| luaK_codek(fs, reg, luaK_numberK(fs, f)); 686| 30.0k|} lcode.c:luaK_numberK: 602| 43.1k|static int luaK_numberK (FuncState *fs, lua_Number r) { 603| 43.1k| TValue o; 604| 43.1k| lua_Integer ik; 605| 43.1k| setfltvalue(&o, r); ------------------ | | 339| 43.1k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 43.1k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 43.1k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 606| 43.1k| if (!luaV_flttointeger(r, &ik, F2Ieq)) /* not an integral value? */ ------------------ | Branch (606:7): [True: 17.4k, False: 25.6k] ------------------ 607| 17.4k| return addk(fs, &o, &o); /* use number itself as key */ 608| 25.6k| else { /* must build an alternative key */ 609| 25.6k| const int nbm = l_floatatt(MANT_DIG); ------------------ | | 466| 25.6k|#define l_floatatt(n) (DBL_##n) ------------------ 610| 25.6k| const lua_Number q = l_mathop(ldexp)(l_mathop(1.0), -nbm + 1); ------------------ | | 473| 25.6k|#define l_mathop(op) op ------------------ const lua_Number q = l_mathop(ldexp)(l_mathop(1.0), -nbm + 1); ------------------ | | 473| 25.6k|#define l_mathop(op) op ------------------ 611| 25.6k| const lua_Number k = (ik == 0) ? q : r + r*q; /* new key */ ------------------ | Branch (611:26): [True: 2.62k, False: 22.9k] ------------------ 612| 25.6k| TValue kv; 613| 25.6k| setfltvalue(&kv, k); ------------------ | | 339| 25.6k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 25.6k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 25.6k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 614| | /* result is not an integral value, unless value is too large */ 615| 25.6k| lua_assert(!luaV_flttointeger(k, &ik, F2Ieq) || ------------------ | | 114| 25.6k|#define lua_assert(c) ((void)0) ------------------ 616| 25.6k| l_mathop(fabs)(r) >= l_mathop(1e6)); 617| 25.6k| return addk(fs, &kv, &o); 618| 25.6k| } 619| 43.1k|} lcode.c:need_value: 898| 3.56M|static int need_value (FuncState *fs, int list) { 899| 3.58M| for (; list != NO_JUMP; list = getjump(fs, list)) { ------------------ | | 20| 3.58M|#define NO_JUMP (-1) ------------------ | Branch (899:10): [True: 3.55M, False: 24.0k] ------------------ 900| 3.55M| Instruction i = *getjumpcontrol(fs, list); 901| 3.55M| if (GET_OPCODE(i) != OP_TESTSET) return 1; ------------------ | | 114| 3.55M|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 3.55M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (901:9): [True: 3.54M, False: 13.8k] ------------------ 902| 3.55M| } 903| 24.0k| return 0; /* not found */ 904| 3.56M|} lcode.c:code_loadbool: 888| 7.08M|static int code_loadbool (FuncState *fs, int A, OpCode op) { 889| 7.08M| luaK_getlabel(fs); /* those instructions may be jump targets */ 890| 7.08M| return luaK_codeABC(fs, op, A, 0, 0); ------------------ | | 48| 7.08M|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 891| 7.08M|} lcode.c:luaK_exp2K: 998| 92.3k|static int luaK_exp2K (FuncState *fs, expdesc *e) { 999| 92.3k| if (!hasjumps(e)) { ------------------ | | 38| 92.3k|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (999:7): [True: 90.1k, False: 2.10k] ------------------ 1000| 90.1k| int info; 1001| 90.1k| switch (e->k) { /* move constants to 'k' */ 1002| 185| case VTRUE: info = boolT(fs); break; ------------------ | Branch (1002:7): [True: 185, False: 90.0k] ------------------ 1003| 0| case VFALSE: info = boolF(fs); break; ------------------ | Branch (1003:7): [True: 0, False: 90.1k] ------------------ 1004| 411| case VNIL: info = nilK(fs); break; ------------------ | Branch (1004:7): [True: 411, False: 89.7k] ------------------ 1005| 41.3k| case VKINT: info = luaK_intK(fs, e->u.ival); break; ------------------ | Branch (1005:7): [True: 41.3k, False: 48.8k] ------------------ 1006| 26.7k| case VKFLT: info = luaK_numberK(fs, e->u.nval); break; ------------------ | Branch (1006:7): [True: 26.7k, False: 63.4k] ------------------ 1007| 244| case VKSTR: info = stringK(fs, e->u.strval); break; ------------------ | Branch (1007:7): [True: 244, False: 89.9k] ------------------ 1008| 109| case VK: info = e->u.info; break; ------------------ | Branch (1008:7): [True: 109, False: 90.0k] ------------------ 1009| 21.2k| default: return 0; /* not a constant */ ------------------ | Branch (1009:7): [True: 21.2k, False: 68.9k] ------------------ 1010| 90.1k| } 1011| 68.9k| if (info <= MAXINDEXRK) { /* does constant fit in 'argC'? */ ------------------ | | 175| 68.9k|#define MAXINDEXRK MAXARG_B | | ------------------ | | | | 96| 68.9k|#define MAXARG_B ((1<k = VK; /* make expression a 'K' expression */ 1013| 52.1k| e->u.info = info; 1014| 52.1k| return 1; 1015| 52.1k| } 1016| 68.9k| } 1017| | /* else, expression doesn't fit; leave it unchanged */ 1018| 18.9k| return 0; 1019| 92.3k|} lcode.c:boolT: 635| 185|static int boolT (FuncState *fs) { 636| 185| TValue o; 637| 185| setbtvalue(&o); ------------------ | | 251| 185|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 185|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 638| 185| return addk(fs, &o, &o); /* use boolean itself as key */ 639| 185|} lcode.c:nilK: 645| 411|static int nilK (FuncState *fs) { 646| 411| TValue k, v; 647| 411| setnilvalue(&v); ------------------ | | 200| 411|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 411|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 648| | /* cannot use nil as key; instead use table itself to represent nil */ 649| 411| sethvalue(fs->ls->L, &k, fs->ls->h); ------------------ | | 687| 411| { TValue *io = (obj); Table *x_ = (x); \ | | 688| 411| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 411|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 390| 411|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 411|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 411|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 689| 411| checkliveness(L,io); } | | ------------------ | | | | 107| 411| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 411|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 411| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 650| 411| return addk(fs, &k, &v); 651| 411|} lcode.c:stringK: 575| 7.22M|static int stringK (FuncState *fs, TString *s) { 576| 7.22M| TValue o; 577| 7.22M| setsvalue(fs->ls->L, &o, s); ------------------ | | 372| 7.22M| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 7.22M| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 7.22M|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 7.22M|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 7.22M|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 7.22M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 7.22M| checkliveness(L,io); } | | ------------------ | | | | 107| 7.22M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 7.22M|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 7.22M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 578| 7.22M| return addk(fs, &o, &o); /* use string itself as key */ 579| 7.22M|} lcode.c:codeABRK: 1039| 21.0k| expdesc *ec) { 1040| 21.0k| int k = luaK_exp2RK(fs, ec); 1041| 21.0k| luaK_codeABCk(fs, o, a, b, ec->u.info, k); 1042| 21.0k|} lcode.c:negatecondition: 1101| 4.56k|static void negatecondition (FuncState *fs, expdesc *e) { 1102| 4.56k| Instruction *pc = getjumpcontrol(fs, e->u.info); 1103| 4.56k| lua_assert(testTMode(GET_OPCODE(*pc)) && GET_OPCODE(*pc) != OP_TESTSET && ------------------ | | 114| 4.56k|#define lua_assert(c) ((void)0) ------------------ 1104| 4.56k| GET_OPCODE(*pc) != OP_TEST); 1105| 4.56k| SETARG_k(*pc, (GETARG_k(*pc) ^ 1)); ------------------ | | 138| 4.56k|#define SETARG_k(i,v) setarg(i, v, POS_k, 1) | | ------------------ | | | | 122| 4.56k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 4.56k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 4.56k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 4.56k| ((cast(Instruction, v)<k == VRELOC) { ------------------ | Branch (1116:7): [True: 20.5k, False: 4.68k] ------------------ 1117| 20.5k| Instruction ie = getinstruction(fs, e); ------------------ | | 55| 20.5k|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 1118| 20.5k| if (GET_OPCODE(ie) == OP_NOT) { ------------------ | | 114| 20.5k|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 20.5k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (1118:9): [True: 661, False: 19.8k] ------------------ 1119| 661| removelastinstruction(fs); /* remove previous OP_NOT */ 1120| 661| return condjump(fs, OP_TEST, GETARG_B(ie), 0, 0, !cond); ------------------ | | 128| 661|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 661|#define check_exp(c,e) (e) | | ------------------ ------------------ 1121| 661| } 1122| | /* else go through */ 1123| 20.5k| } 1124| 24.5k| discharge2anyreg(fs, e); 1125| 24.5k| freeexp(fs, e); 1126| 24.5k| return condjump(fs, OP_TESTSET, NO_REG, e->u.info, 0, cond); ------------------ | | 182| 24.5k|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 24.5k|#define MAXARG_A ((1<pc--; 375| 661|} lcode.c:condjump: 222| 3.66M|static int condjump (FuncState *fs, OpCode op, int A, int B, int C, int k) { 223| 3.66M| luaK_codeABCk(fs, op, A, B, C, k); 224| 3.66M| return luaK_jump(fs); 225| 3.66M|} lcode.c:discharge2anyreg: 880| 29.7k|static void discharge2anyreg (FuncState *fs, expdesc *e) { 881| 29.7k| if (e->k != VNONRELOC) { /* no fixed register yet? */ ------------------ | Branch (881:7): [True: 24.3k, False: 5.38k] ------------------ 882| 24.3k| luaK_reserveregs(fs, 1); /* get a register */ 883| 24.3k| discharge2reg(fs, e, fs->freereg-1); /* put value there */ 884| 24.3k| } 885| 29.7k|} lcode.c:str2K: 737| 7.22M|static void str2K (FuncState *fs, expdesc *e) { 738| 7.22M| lua_assert(e->k == VKSTR); ------------------ | | 114| 7.22M|#define lua_assert(c) ((void)0) ------------------ 739| 7.22M| e->u.info = stringK(fs, e->u.strval); 740| 7.22M| e->k = VK; 741| 7.22M|} lcode.c:isKstr: 1220| 8.40M|static int isKstr (FuncState *fs, expdesc *e) { 1221| 8.40M| return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B && ------------------ | | 38| 16.8M|#define hasjumps(e) ((e)->t != (e)->f) ------------------ return (e->k == VK && !hasjumps(e) && e->u.info <= MAXARG_B && ------------------ | | 96| 16.8M|#define MAXARG_B ((1<f->k[e->u.info])); ------------------ | | 364| 5.55M|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | ------------------ | | | | 91| 5.55M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 5.55M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 5.55M, False: 1.18k] | | | | ------------------ | | ------------------ ------------------ 1223| 8.40M|} lcode.c:isCint: 1237| 1.44M|static int isCint (expdesc *e) { 1238| 1.44M| return luaK_isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C)); ------------------ | | 152| 1.82k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ return luaK_isKint(e) && (l_castS2U(e->u.ival) <= l_castS2U(MAXARG_C)); ------------------ | | 152| 1.82k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (1238:10): [True: 1.82k, False: 1.43M] | Branch (1238:28): [True: 1.81k, False: 7] ------------------ 1239| 1.44M|} lcode.c:constfolding: 1334| 3.71M| const expdesc *e2) { 1335| 3.71M| TValue v1, v2, res; 1336| 3.71M| if (!tonumeral(e1, &v1) || !tonumeral(e2, &v2) || !validop(op, &v1, &v2)) ------------------ | Branch (1336:7): [True: 3.56M, False: 144k] | Branch (1336:30): [True: 24.2k, False: 120k] | Branch (1336:53): [True: 6.52k, False: 113k] ------------------ 1337| 3.59M| return 0; /* non-numeric operands or not safe to fold */ 1338| 113k| luaO_rawarith(fs->ls->L, op, &v1, &v2, &res); /* does operation */ 1339| 113k| if (ttisinteger(&res)) { ------------------ | | 328| 113k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 113k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 113k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 43.7k, False: 69.9k] | | | | ------------------ | | ------------------ ------------------ 1340| 43.7k| e1->k = VKINT; 1341| 43.7k| e1->u.ival = ivalue(&res); ------------------ | | 333| 43.7k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 43.7k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1342| 43.7k| } 1343| 69.9k| else { /* folds neither NaN nor 0.0 (to avoid problems with -0.0) */ 1344| 69.9k| lua_Number n = fltvalue(&res); ------------------ | | 332| 69.9k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 69.9k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1345| 69.9k| if (luai_numisnan(n) || n == 0) ------------------ | | 355| 139k|#define luai_numisnan(a) (!luai_numeq((a), (a))) | | ------------------ | | | | 350| 69.9k|#define luai_numeq(a,b) ((a)==(b)) | | ------------------ | | | Branch (355:33): [True: 11, False: 69.9k] | | ------------------ ------------------ | Branch (1345:29): [True: 7.72k, False: 62.2k] ------------------ 1346| 7.73k| return 0; 1347| 62.2k| e1->k = VKFLT; 1348| 62.2k| e1->u.nval = n; 1349| 62.2k| } 1350| 105k| return 1; 1351| 113k|} lcode.c:validop: 1314| 120k|static int validop (int op, TValue *v1, TValue *v2) { 1315| 120k| switch (op) { 1316| 2.33k| case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 222| 1.12k|#define LUA_OPBAND 7 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 223| 1.14k|#define LUA_OPBOR 8 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 224| 2.33k|#define LUA_OPBXOR 9 ------------------ | Branch (1316:5): [True: 1.12k, False: 119k] | Branch (1316:22): [True: 21, False: 120k] | Branch (1316:38): [True: 1.19k, False: 119k] ------------------ 1317| 37.4k| case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ ------------------ | | 225| 2.64k|#define LUA_OPSHL 10 ------------------ case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ ------------------ | | 226| 3.12k|#define LUA_OPSHR 11 ------------------ case LUA_OPSHL: case LUA_OPSHR: case LUA_OPBNOT: { /* conversion errors */ ------------------ | | 228| 37.4k|#define LUA_OPBNOT 13 ------------------ | Branch (1317:5): [True: 312, False: 119k] | Branch (1317:21): [True: 473, False: 119k] | Branch (1317:37): [True: 34.2k, False: 85.9k] ------------------ 1318| 37.4k| lua_Integer i; 1319| 37.4k| return (luaV_tointegerns(v1, &i, LUA_FLOORN2I) && ------------------ | | 36| 37.4k|#define LUA_FLOORN2I F2Ieq ------------------ | Branch (1319:15): [True: 31.0k, False: 6.34k] ------------------ 1320| 37.4k| luaV_tointegerns(v2, &i, LUA_FLOORN2I)); ------------------ | | 36| 31.0k|#define LUA_FLOORN2I F2Ieq ------------------ | Branch (1320:15): [True: 30.9k, False: 161] ------------------ 1321| 3.12k| } 1322| 6.06k| case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ ------------------ | | 220| 175|#define LUA_OPDIV 5 ------------------ case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ ------------------ | | 221| 215|#define LUA_OPIDIV 6 ------------------ case LUA_OPDIV: case LUA_OPIDIV: case LUA_OPMOD: /* division by 0 */ ------------------ | | 218| 6.06k|#define LUA_OPMOD 3 ------------------ | Branch (1322:5): [True: 175, False: 120k] | Branch (1322:21): [True: 40, False: 120k] | Branch (1322:38): [True: 5.85k, False: 114k] ------------------ 1323| 6.06k| return (nvalue(v2) != 0); ------------------ | | 330| 6.06k|#define nvalue(o) check_exp(ttisnumber(o), \ | | ------------------ | | | | 115| 12.1k|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:26): [True: 4.66k, False: 1.40k] | | | | ------------------ | | ------------------ | | 331| 6.06k| (ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o))) ------------------ 1324| 76.7k| default: return 1; /* everything else is valid */ ------------------ | Branch (1324:5): [True: 76.7k, False: 43.4k] ------------------ 1325| 120k| } 1326| 120k|} lcode.c:codeunexpval: 1388| 157k|static void codeunexpval (FuncState *fs, OpCode op, expdesc *e, int line) { 1389| 157k| int r = luaK_exp2anyreg(fs, e); /* opcodes operate only on registers */ 1390| 157k| freeexp(fs, e); 1391| 157k| e->u.info = luaK_codeABC(fs, op, 0, r, 0); /* generate opcode */ ------------------ | | 48| 157k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1392| 157k| e->k = VRELOC; /* all those operations are relocatable */ 1393| 157k| luaK_fixline(fs, line); 1394| 157k|} lcode.c:unopr2op: 1368| 157k|l_sinline OpCode unopr2op (UnOpr opr) { 1369| 157k| return cast(OpCode, (cast_int(opr) - cast_int(OPR_MINUS)) + ------------------ | | 136| 157k|#define cast(t, exp) ((t)(exp)) ------------------ 1370| 157k| cast_int(OP_UNM)); 1371| 157k|} lcode.c:codenot: 1186| 6.12k|static void codenot (FuncState *fs, expdesc *e) { 1187| 6.12k| switch (e->k) { 1188| 13| case VNIL: case VFALSE: { ------------------ | Branch (1188:5): [True: 0, False: 6.12k] | Branch (1188:16): [True: 13, False: 6.11k] ------------------ 1189| 13| e->k = VTRUE; /* true == not nil == not false */ 1190| 13| break; 1191| 0| } 1192| 699| case VK: case VKFLT: case VKINT: case VKSTR: case VTRUE: { ------------------ | Branch (1192:5): [True: 0, False: 6.12k] | Branch (1192:14): [True: 191, False: 5.93k] | Branch (1192:26): [True: 473, False: 5.65k] | Branch (1192:38): [True: 0, False: 6.12k] | Branch (1192:50): [True: 35, False: 6.08k] ------------------ 1193| 699| e->k = VFALSE; /* false == not "x" == not 0.5 == not 1 == not true */ 1194| 699| break; 1195| 664| } 1196| 231| case VJMP: { ------------------ | Branch (1196:5): [True: 231, False: 5.89k] ------------------ 1197| 231| negatecondition(fs, e); 1198| 231| break; 1199| 664| } 1200| 3.78k| case VRELOC: ------------------ | Branch (1200:5): [True: 3.78k, False: 2.34k] ------------------ 1201| 5.18k| case VNONRELOC: { ------------------ | Branch (1201:5): [True: 1.40k, False: 4.72k] ------------------ 1202| 5.18k| discharge2anyreg(fs, e); 1203| 5.18k| freeexp(fs, e); 1204| 5.18k| e->u.info = luaK_codeABC(fs, OP_NOT, 0, e->u.info, 0); ------------------ | | 48| 5.18k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1205| 5.18k| e->k = VRELOC; 1206| 5.18k| break; 1207| 3.78k| } 1208| 0| default: lua_assert(0); /* cannot happen */ ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (1208:5): [True: 0, False: 6.12k] ------------------ 1209| 6.12k| } 1210| | /* interchange true and false lists */ 1211| 6.12k| { int temp = e->f; e->f = e->t; e->t = temp; } 1212| 6.12k| removevalues(fs, e->f); /* values are useless when negated */ 1213| 6.12k| removevalues(fs, e->t); 1214| 6.12k|} lcode.c:removevalues: 277| 12.2k|static void removevalues (FuncState *fs, int list) { 278| 77.7k| for (; list != NO_JUMP; list = getjump(fs, list)) ------------------ | | 20| 77.7k|#define NO_JUMP (-1) ------------------ | Branch (278:10): [True: 65.5k, False: 12.2k] ------------------ 279| 65.5k| patchtestreg(fs, list, NO_REG); ------------------ | | 182| 65.5k|#define NO_REG MAXARG_A | | ------------------ | | | | 95| 65.5k|#define MAXARG_A ((1<k == VKINT) ------------------ | Branch (1257:7): [True: 19.0k, False: 10.8M] ------------------ 1258| 19.0k| i = e->u.ival; 1259| 10.8M| else if (e->k == VKFLT && luaV_flttointeger(e->u.nval, &i, F2Ieq)) ------------------ | Branch (1259:12): [True: 4.15k, False: 10.8M] | Branch (1259:29): [True: 4.08k, False: 61] ------------------ 1260| 4.08k| *isfloat = 1; 1261| 10.8M| else 1262| 10.8M| return 0; /* not a number */ 1263| 23.1k| if (!hasjumps(e) && fitsC(i)) { ------------------ | | 38| 46.3k|#define hasjumps(e) ((e)->t != (e)->f) ------------------ | Branch (1263:7): [True: 18.5k, False: 4.65k] | Branch (1263:23): [True: 16.0k, False: 2.45k] ------------------ 1264| 16.0k| *pi = int2sC(cast_int(i)); ------------------ | | 100| 16.0k|#define int2sC(i) ((i) + OFFSET_sC) | | ------------------ | | | | 98| 16.0k|#define OFFSET_sC (MAXARG_C >> 1) | | | | ------------------ | | | | | | 97| 16.0k|#define MAXARG_C ((1<> 1) | | ------------------ | | | | 97| 56.5k|#define MAXARG_C ((1<>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 6.33k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (1684:7): [True: 0, False: 6.33k] ------------------ 1685| 0| int n = GETARG_B(*ie2); /* # of elements concatenated in 'e2' */ ------------------ | | 128| 0|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1686| 0| lua_assert(e1->u.info + 1 == GETARG_A(*ie2)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 1687| 0| freeexp(fs, e2); 1688| 0| SETARG_A(*ie2, e1->u.info); /* correct first element ('e1') */ ------------------ | | 126| 0|#define SETARG_A(i,v) setarg(i, v, POS_A, SIZE_A) | | ------------------ | | | | 122| 0|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 0|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 0|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 0| ((cast(Instruction, v)<u.info, 2, 0); /* new concat opcode */ ------------------ | | 48| 6.33k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1693| 6.33k| freeexp(fs, e2); 1694| 6.33k| luaK_fixline(fs, line); 1695| 6.33k| } 1696| 6.33k|} lcode.c:codecommutative: 1514| 18.8k| expdesc *e1, expdesc *e2, int line) { 1515| 18.8k| int flip = 0; 1516| 18.8k| if (tonumeral(e1, NULL)) { /* is first operand a numeric constant? */ ------------------ | Branch (1516:7): [True: 2.21k, False: 16.6k] ------------------ 1517| 2.21k| swapexps(e1, e2); /* change order */ 1518| 2.21k| flip = 1; 1519| 2.21k| } 1520| 18.8k| if (op == OPR_ADD && isSCint(e2)) /* immediate operand? */ ------------------ | Branch (1520:7): [True: 2.73k, False: 16.1k] | Branch (1520:24): [True: 150, False: 2.58k] ------------------ 1521| 150| codebini(fs, OP_ADDI, e1, e2, flip, line, TM_ADD); 1522| 18.7k| else 1523| 18.7k| codearith(fs, op, e1, e2, flip, line); 1524| 18.8k|} lcode.c:finishbinexpneg: 1461| 227k| OpCode op, int line, TMS event) { 1462| 227k| if (!luaK_isKint(e2)) ------------------ | Branch (1462:7): [True: 211k, False: 16.0k] ------------------ 1463| 211k| return 0; /* not an integer constant */ 1464| 16.0k| else { 1465| 16.0k| lua_Integer i2 = e2->u.ival; 1466| 16.0k| if (!(fitsC(i2) && fitsC(-i2))) ------------------ | Branch (1466:11): [True: 15.4k, False: 603] | Branch (1466:24): [True: 15.4k, False: 0] ------------------ 1467| 603| return 0; /* not in the proper range */ 1468| 15.4k| else { /* operating a small integer constant */ 1469| 15.4k| int v2 = cast_int(i2); ------------------ | | 141| 15.4k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 15.4k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1470| 15.4k| finishbinexpval(fs, e1, e2, op, int2sC(-v2), 0, line, OP_MMBINI, event); ------------------ | | 100| 15.4k|#define int2sC(i) ((i) + OFFSET_sC) | | ------------------ | | | | 98| 15.4k|#define OFFSET_sC (MAXARG_C >> 1) | | | | ------------------ | | | | | | 97| 15.4k|#define MAXARG_C ((1<f->code[fs->pc - 1], int2sC(v2)); ------------------ | | 130| 15.4k|#define SETARG_B(i,v) setarg(i, v, POS_B, SIZE_B) | | ------------------ | | | | 122| 15.4k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 15.4k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 15.4k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 15.4k| ((cast(Instruction, v)<u.info = pc; 1410| 3.46M| e1->k = VRELOC; /* all those operations are relocatable */ 1411| 3.46M| luaK_fixline(fs, line); 1412| 3.46M| luaK_codeABCk(fs, mmop, v1, v2, event, flip); /* to call metamethod */ 1413| 3.46M| luaK_fixline(fs, line); 1414| 3.46M|} lcode.c:freeexps: 527| 7.10M|static void freeexps (FuncState *fs, expdesc *e1, expdesc *e2) { 528| 7.10M| int r1 = (e1->k == VNONRELOC) ? e1->u.info : -1; ------------------ | Branch (528:12): [True: 7.09M, False: 4.25k] ------------------ 529| 7.10M| int r2 = (e2->k == VNONRELOC) ? e2->u.info : -1; ------------------ | Branch (529:12): [True: 7.02M, False: 75.6k] ------------------ 530| 7.10M| freeregs(fs, r1, r2); 531| 7.10M|} lcode.c:codearith: 1500| 3.20M| expdesc *e1, expdesc *e2, int flip, int line) { 1501| 3.20M| if (tonumeral(e2, NULL) && luaK_exp2K(fs, e2)) /* K operand? */ ------------------ | Branch (1501:7): [True: 46.8k, False: 3.15M] | Branch (1501:30): [True: 33.9k, False: 12.9k] ------------------ 1502| 33.9k| codebinK(fs, opr, e1, e2, flip, line); 1503| 3.17M| else /* 'e2' is neither an immediate nor a K operand */ 1504| 3.17M| codebinNoK(fs, opr, e1, e2, flip, line); 1505| 3.20M|} lcode.c:codebinK: 1449| 49.8k| expdesc *e1, expdesc *e2, int flip, int line) { 1450| 49.8k| TMS event = binopr2TM(opr); 1451| 49.8k| int v2 = e2->u.info; /* K index */ 1452| 49.8k| OpCode op = binopr2op(opr, OPR_ADD, OP_ADDK); 1453| 49.8k| finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINK, event); 1454| 49.8k|} lcode.c:binopr2TM: 1377| 3.44M|l_sinline TMS binopr2TM (BinOpr opr) { 1378| 3.44M| lua_assert(OPR_ADD <= opr && opr <= OPR_SHR); ------------------ | | 114| 3.44M|#define lua_assert(c) ((void)0) ------------------ 1379| 3.44M| return cast(TMS, (cast_int(opr) - cast_int(OPR_ADD)) + cast_int(TM_ADD)); ------------------ | | 136| 3.44M|#define cast(t, exp) ((t)(exp)) ------------------ 1380| 3.44M|} lcode.c:binopr2op: 1357| 7.07M|l_sinline OpCode binopr2op (BinOpr opr, BinOpr baser, OpCode base) { 1358| 7.07M| lua_assert(baser <= opr && ------------------ | | 114| 7.07M|#define lua_assert(c) ((void)0) ------------------ 1359| 7.07M| ((baser == OPR_ADD && opr <= OPR_SHR) || 1360| 7.07M| (baser == OPR_LT && opr <= OPR_LE))); 1361| 7.07M| return cast(OpCode, (cast_int(opr) - cast_int(baser)) + cast_int(base)); ------------------ | | 136| 7.07M|#define cast(t, exp) ((t)(exp)) ------------------ 1362| 7.07M|} lcode.c:codebinNoK: 1488| 3.19M| expdesc *e1, expdesc *e2, int flip, int line) { 1489| 3.19M| if (flip) ------------------ | Branch (1489:7): [True: 623, False: 3.19M] ------------------ 1490| 623| swapexps(e1, e2); /* back to original order */ 1491| 3.19M| codebinexpval(fs, opr, e1, e2, line); /* use standard operators */ 1492| 3.19M|} lcode.c:codebitwise: 1532| 44.8k| expdesc *e1, expdesc *e2, int line) { 1533| 44.8k| int flip = 0; 1534| 44.8k| if (e1->k == VKINT) { ------------------ | Branch (1534:7): [True: 3.45k, False: 41.4k] ------------------ 1535| 3.45k| swapexps(e1, e2); /* 'e2' will be the constant operand */ 1536| 3.45k| flip = 1; 1537| 3.45k| } 1538| 44.8k| if (e2->k == VKINT && luaK_exp2K(fs, e2)) /* K operand? */ ------------------ | Branch (1538:7): [True: 19.7k, False: 25.1k] | Branch (1538:25): [True: 15.8k, False: 3.86k] ------------------ 1539| 15.8k| codebinK(fs, opr, e1, e2, flip, line); 1540| 28.9k| else /* no constants */ 1541| 28.9k| codebinNoK(fs, opr, e1, e2, flip, line); 1542| 44.8k|} lcode.c:isSCint: 1246| 208k|static int isSCint (expdesc *e) { 1247| 208k| return luaK_isKint(e) && fitsC(e->u.ival); ------------------ | Branch (1247:10): [True: 6.43k, False: 202k] | Branch (1247:28): [True: 4.53k, False: 1.89k] ------------------ 1248| 208k|} lcode.c:swapexps: 1479| 46.9k|static void swapexps (expdesc *e1, expdesc *e2) { 1480| 46.9k| expdesc temp = *e1; *e1 = *e2; *e2 = temp; /* swap 'e1' and 'e2' */ 1481| 46.9k|} lcode.c:codebini: 1438| 4.53k| TMS event) { 1439| 4.53k| int v2 = int2sC(cast_int(e2->u.ival)); /* immediate operand */ ------------------ | | 100| 4.53k|#define int2sC(i) ((i) + OFFSET_sC) | | ------------------ | | | | 98| 4.53k|#define OFFSET_sC (MAXARG_C >> 1) | | | | ------------------ | | | | | | 97| 4.53k|#define MAXARG_C ((1<k == VKINT); ------------------ | | 114| 4.53k|#define lua_assert(c) ((void)0) ------------------ 1441| 4.53k| finishbinexpval(fs, e1, e2, op, v2, flip, line, OP_MMBINI, event); 1442| 4.53k|} lcode.c:codebinexpval: 1422| 3.39M| expdesc *e1, expdesc *e2, int line) { 1423| 3.39M| OpCode op = binopr2op(opr, OPR_ADD, OP_ADD); 1424| 3.39M| int v2 = luaK_exp2anyreg(fs, e2); /* make sure 'e2' is in a register */ 1425| | /* 'e1' must be already in a register or it is a constant */ 1426| 3.39M| lua_assert((VNIL <= e1->k && e1->k <= VKSTR) || ------------------ | | 114| 3.39M|#define lua_assert(c) ((void)0) ------------------ 1427| 3.39M| e1->k == VNONRELOC || e1->k == VRELOC); 1428| 3.39M| lua_assert(OP_ADD <= op && op <= OP_SHR); ------------------ | | 114| 3.39M|#define lua_assert(c) ((void)0) ------------------ 1429| 3.39M| finishbinexpval(fs, e1, e2, op, v2, 0, line, OP_MMBIN, binopr2TM(opr)); 1430| 3.39M|} lcode.c:codeeq: 1581| 3.75k|static void codeeq (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) { 1582| 3.75k| int r1, r2; 1583| 3.75k| int im; 1584| 3.75k| int isfloat = 0; /* not needed here, but kept for symmetry */ 1585| 3.75k| OpCode op; 1586| 3.75k| if (e1->k != VNONRELOC) { ------------------ | Branch (1586:7): [True: 1.34k, False: 2.41k] ------------------ 1587| 1.34k| lua_assert(e1->k == VK || e1->k == VKINT || e1->k == VKFLT); ------------------ | | 114| 1.34k|#define lua_assert(c) ((void)0) ------------------ 1588| 1.34k| swapexps(e1, e2); 1589| 1.34k| } 1590| 3.75k| r1 = luaK_exp2anyreg(fs, e1); /* 1st expression must be in register */ 1591| 3.75k| if (isSCnumber(e2, &im, &isfloat)) { ------------------ | Branch (1591:7): [True: 1.83k, False: 1.91k] ------------------ 1592| 1.83k| op = OP_EQI; 1593| 1.83k| r2 = im; /* immediate operand */ 1594| 1.83k| } 1595| 1.91k| else if (luaK_exp2RK(fs, e2)) { /* 2nd expression is constant? */ ------------------ | Branch (1595:12): [True: 334, False: 1.58k] ------------------ 1596| 334| op = OP_EQK; 1597| 334| r2 = e2->u.info; /* constant index */ 1598| 334| } 1599| 1.58k| else { 1600| 1.58k| op = OP_EQ; /* will compare two registers */ 1601| 1.58k| r2 = luaK_exp2anyreg(fs, e2); 1602| 1.58k| } 1603| 3.75k| freeexps(fs, e1, e2); 1604| 3.75k| e1->u.info = condjump(fs, op, r1, r2, isfloat, (opr == OPR_EQ)); 1605| 3.75k| e1->k = VJMP; 1606| 3.75k|} lcode.c:codeorder: 1549| 3.63M|static void codeorder (FuncState *fs, BinOpr opr, expdesc *e1, expdesc *e2) { 1550| 3.63M| int r1, r2; 1551| 3.63M| int im; 1552| 3.63M| int isfloat = 0; 1553| 3.63M| OpCode op; 1554| 3.63M| if (isSCnumber(e2, &im, &isfloat)) { ------------------ | Branch (1554:7): [True: 3.67k, False: 3.62M] ------------------ 1555| | /* use immediate operand */ 1556| 3.67k| r1 = luaK_exp2anyreg(fs, e1); 1557| 3.67k| r2 = im; 1558| 3.67k| op = binopr2op(opr, OPR_LT, OP_LTI); 1559| 3.67k| } 1560| 3.62M| else if (isSCnumber(e1, &im, &isfloat)) { ------------------ | Branch (1560:12): [True: 4.25k, False: 3.62M] ------------------ 1561| | /* transform (A < B) to (B > A) and (A <= B) to (B >= A) */ 1562| 4.25k| r1 = luaK_exp2anyreg(fs, e2); 1563| 4.25k| r2 = im; 1564| 4.25k| op = binopr2op(opr, OPR_LT, OP_GTI); 1565| 4.25k| } 1566| 3.62M| else { /* regular case, compare two registers */ 1567| 3.62M| r1 = luaK_exp2anyreg(fs, e1); 1568| 3.62M| r2 = luaK_exp2anyreg(fs, e2); 1569| 3.62M| op = binopr2op(opr, OPR_LT, OP_LT); 1570| 3.62M| } 1571| 3.63M| freeexps(fs, e1, e2); 1572| 3.63M| e1->u.info = condjump(fs, op, r1, r2, isfloat, 1); 1573| 3.63M| e1->k = VJMP; 1574| 3.63M|} lcode.c:removelastlineinfo: 353| 7.31M|static void removelastlineinfo (FuncState *fs) { 354| 7.31M| Proto *f = fs->f; 355| 7.31M| int pc = fs->pc - 1; /* last instruction coded */ 356| 7.31M| if (f->lineinfo[pc] != ABSLINEINFO) { /* relative line info? */ ------------------ | | 27| 7.31M|#define ABSLINEINFO (-0x80) ------------------ | Branch (356:7): [True: 7.25M, False: 56.6k] ------------------ 357| 7.25M| fs->previousline -= f->lineinfo[pc]; /* correct last line saved */ 358| 7.25M| fs->iwthabs--; /* undo previous increment */ 359| 7.25M| } 360| 56.6k| else { /* absolute line information */ 361| 56.6k| lua_assert(f->abslineinfo[fs->nabslineinfo - 1].pc == pc); ------------------ | | 114| 56.6k|#define lua_assert(c) ((void)0) ------------------ 362| 56.6k| fs->nabslineinfo--; /* remove it */ 363| 56.6k| fs->iwthabs = MAXIWTHABS + 1; /* force next line info to be absolute */ ------------------ | | 35| 56.6k|#define MAXIWTHABS 128 ------------------ 364| 56.6k| } 365| 7.31M|} lcode.c:finaltarget: 1826| 41.9k|static int finaltarget (Instruction *code, int i) { 1827| 41.9k| int count; 1828| 83.8k| for (count = 0; count < 100; count++) { /* avoid infinite loops */ ------------------ | Branch (1828:19): [True: 83.8k, False: 0] ------------------ 1829| 83.8k| Instruction pc = code[i]; 1830| 83.8k| if (GET_OPCODE(pc) != OP_JMP) ------------------ | | 114| 83.8k|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 83.8k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (1830:9): [True: 41.9k, False: 41.9k] ------------------ 1831| 41.9k| break; 1832| 41.9k| else 1833| 41.9k| i += GETARG_sJ(pc) + 1; ------------------ | | 151| 41.9k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | ------------------ | | | | 115| 41.9k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1834| 83.8k| } 1835| 41.9k| return i; 1836| 41.9k|} luaG_getfuncline: 83| 99|int luaG_getfuncline (const Proto *f, int pc) { 84| 99| if (f->lineinfo == NULL) /* no debug information? */ ------------------ | Branch (84:7): [True: 0, False: 99] ------------------ 85| 0| return -1; 86| 99| else { 87| 99| int basepc; 88| 99| int baseline = getbaseline(f, pc, &basepc); 89| 3.09k| while (basepc++ < pc) { /* walk until given instruction */ ------------------ | Branch (89:12): [True: 3.00k, False: 99] ------------------ 90| 3.00k| lua_assert(f->lineinfo[basepc] != ABSLINEINFO); ------------------ | | 114| 3.00k|#define lua_assert(c) ((void)0) ------------------ 91| 3.00k| baseline += f->lineinfo[basepc]; /* correct line */ 92| 3.00k| } 93| 99| return baseline; 94| 99| } 95| 99|} lua_getstack: 160| 238|LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) { 161| 238| int status; 162| 238| CallInfo *ci; 163| 238| if (level < 0) return 0; /* invalid (negative) level */ ------------------ | Branch (163:7): [True: 0, False: 238] ------------------ 164| 238| lua_lock(L); ------------------ | | 264| 238|#define lua_lock(L) ((void) 0) ------------------ 165| 32.5k| for (ci = L->ci; level > 0 && ci != &L->base_ci; ci = ci->previous) ------------------ | Branch (165:20): [True: 32.3k, False: 232] | Branch (165:33): [True: 32.3k, False: 6] ------------------ 166| 32.3k| level--; 167| 238| if (level == 0 && ci != &L->base_ci) { /* level found? */ ------------------ | Branch (167:7): [True: 232, False: 6] | Branch (167:21): [True: 154, False: 78] ------------------ 168| 154| status = 1; 169| 154| ar->i_ci = ci; 170| 154| } 171| 84| else status = 0; /* no such level */ 172| 238| lua_unlock(L); ------------------ | | 265| 238|#define lua_unlock(L) ((void) 0) ------------------ 173| 238| return status; 174| 238|} luaG_findlocal: 196| 1|const char *luaG_findlocal (lua_State *L, CallInfo *ci, int n, StkId *pos) { 197| 1| StkId base = ci->func.p + 1; 198| 1| const char *name = NULL; 199| 1| if (isLua(ci)) { ------------------ | | 241| 1|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 1|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 1, False: 0] | | ------------------ ------------------ 200| 1| if (n < 0) /* access to vararg values? */ ------------------ | Branch (200:9): [True: 0, False: 1] ------------------ 201| 0| return findvararg(ci, n, pos); 202| 1| else 203| 1| name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci)); ------------------ | | 18| 1|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 604| 1|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 204| 1| } 205| 1| if (name == NULL) { /* no 'standard' name? */ ------------------ | Branch (205:7): [True: 0, False: 1] ------------------ 206| 0| StkId limit = (ci == L->ci) ? L->top.p : ci->next->func.p; ------------------ | Branch (206:19): [True: 0, False: 0] ------------------ 207| 0| if (limit - base >= n && n > 0) { /* is 'n' inside 'ci' stack? */ ------------------ | Branch (207:9): [True: 0, False: 0] | Branch (207:30): [True: 0, False: 0] ------------------ 208| | /* generic name for any valid slot */ 209| 0| name = isLua(ci) ? "(temporary)" : "(C temporary)"; ------------------ | | 241| 0|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 0|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 0, False: 0] | | ------------------ ------------------ 210| 0| } 211| 0| else 212| 0| return NULL; /* no name */ 213| 0| } 214| 1| if (pos) ------------------ | Branch (214:7): [True: 0, False: 1] ------------------ 215| 0| *pos = base + (n - 1); 216| 1| return name; 217| 1|} lua_getinfo: 383| 120|LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) { 384| 120| int status; 385| 120| Closure *cl; 386| 120| CallInfo *ci; 387| 120| TValue *func; 388| 120| lua_lock(L); ------------------ | | 264| 120|#define lua_lock(L) ((void) 0) ------------------ 389| 120| if (*what == '>') { ------------------ | Branch (389:7): [True: 0, False: 120] ------------------ 390| 0| ci = NULL; 391| 0| func = s2v(L->top.p - 1); ------------------ | | 172| 0|#define s2v(o) (&(o)->val) ------------------ 392| 0| api_check(L, ttisfunction(func), "function expected"); ------------------ | | 126| 0|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | ------------------ | | | | 123| 0|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 393| 0| what++; /* skip the '>' */ 394| 0| L->top.p--; /* pop function */ 395| 0| } 396| 120| else { 397| 120| ci = ar->i_ci; 398| 120| func = s2v(ci->func.p); ------------------ | | 172| 120|#define s2v(o) (&(o)->val) ------------------ 399| 120| lua_assert(ttisfunction(func)); ------------------ | | 114| 120|#define lua_assert(c) ((void)0) ------------------ 400| 120| } 401| 120| cl = ttisclosure(func) ? clvalue(func) : NULL; ------------------ | | 598| 120|#define ttisclosure(o) (ttisLclosure(o) || ttisCclosure(o)) | | ------------------ | | | | 595| 120|#define ttisLclosure(o) checktag((o), ctb(LUA_VLCL)) | | | | ------------------ | | | | | | 91| 240|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 120|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 120, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define ttisclosure(o) (ttisLclosure(o) || ttisCclosure(o)) | | ------------------ | | | | 597| 0|#define ttisCclosure(o) checktag((o), ctb(LUA_VCCL)) | | | | ------------------ | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ cl = ttisclosure(func) ? clvalue(func) : NULL; ------------------ | | 603| 120|#define clvalue(o) check_exp(ttisclosure(o), gco2cl(val_(o).gc)) | | ------------------ | | | | 115| 120|#define check_exp(c,e) (e) | | ------------------ ------------------ 402| 120| status = auxgetinfo(L, what, ar, cl, ci); 403| 120| if (strchr(what, 'f')) { ------------------ | Branch (403:7): [True: 60, False: 60] ------------------ 404| 60| setobj2s(L, L->top.p, func); ------------------ | | 131| 60|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 60| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 60| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 60|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 60| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 60| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 60|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 60| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 60|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 405| 60| api_incr_top(L); ------------------ | | 16| 60|#define api_incr_top(L) {L->top.p++; \ | | 17| 60| api_check(L, L->top.p <= L->ci->top.p, \ | | ------------------ | | | | 126| 60|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 60|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 60|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 18| 60| "stack overflow");} ------------------ 406| 60| } 407| 120| if (strchr(what, 'L')) ------------------ | Branch (407:7): [True: 0, False: 120] ------------------ 408| 0| collectvalidlines(L, cl); 409| 120| lua_unlock(L); ------------------ | | 265| 120|#define lua_unlock(L) ((void) 0) ------------------ 410| 120| return status; 411| 120|} luaG_typeerror: 736| 30|l_noret luaG_typeerror (lua_State *L, const TValue *o, const char *op) { 737| 30| typeerror(L, o, op, varinfo(L, o)); 738| 30|} luaG_callerror: 746| 1|l_noret luaG_callerror (lua_State *L, const TValue *o) { 747| 1| CallInfo *ci = L->ci; 748| 1| const char *name = NULL; /* to avoid warnings */ 749| 1| const char *kind = funcnamefromcall(L, ci, &name); 750| 1| const char *extra = kind ? formatvarinfo(L, kind, name) : varinfo(L, o); ------------------ | Branch (750:23): [True: 0, False: 1] ------------------ 751| 1| typeerror(L, o, "call", extra); 752| 1|} luaG_forerror: 755| 5|l_noret luaG_forerror (lua_State *L, const TValue *o, const char *what) { 756| 5| luaG_runerror(L, "bad 'for' %s (number expected, got %s)", 757| 5| what, luaT_objtypename(L, o)); 758| 5|} luaG_opinterror: 768| 28| const TValue *p2, const char *msg) { 769| 28| if (!ttisnumber(p1)) /* first operand is wrong? */ ------------------ | | 326| 28|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | ------------------ | | | | 92| 28|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 28|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 28|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (769:7): [True: 27, False: 1] ------------------ 770| 27| p2 = p1; /* now second is wrong */ 771| 28| luaG_typeerror(L, p2, msg); 772| 28|} luaG_ordererror: 786| 1|l_noret luaG_ordererror (lua_State *L, const TValue *p1, const TValue *p2) { 787| 1| const char *t1 = luaT_objtypename(L, p1); 788| 1| const char *t2 = luaT_objtypename(L, p2); 789| 1| if (strcmp(t1, t2) == 0) ------------------ | Branch (789:7): [True: 0, False: 1] ------------------ 790| 0| luaG_runerror(L, "attempt to compare two %s values", t1); 791| 1| else 792| 1| luaG_runerror(L, "attempt to compare %s with %s", t1, t2); 793| 1|} luaG_addinfo: 798| 255| int line) { 799| 255| char buff[LUA_IDSIZE]; 800| 255| if (src) ------------------ | Branch (800:7): [True: 255, False: 0] ------------------ 801| 255| luaO_chunkid(buff, getstr(src), tsslen(src)); ------------------ | | 403| 255|#define getstr(ts) ((ts)->contents) ------------------ luaO_chunkid(buff, getstr(src), tsslen(src)); ------------------ | | 410| 255|#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | | 360| 255|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | ------------------ | | | | | | 42| 255|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (410:20): [True: 255, False: 0] | | ------------------ ------------------ 802| 0| else { /* no source available; use "?" instead */ 803| 0| buff[0] = '?'; buff[1] = '\0'; 804| 0| } 805| 255| return luaO_pushfstring(L, "%s:%d: %s", buff, line, msg); 806| 255|} luaG_errormsg: 809| 41|l_noret luaG_errormsg (lua_State *L) { 810| 41| if (L->errfunc != 0) { /* is there an error handling function? */ ------------------ | Branch (810:7): [True: 39, False: 2] ------------------ 811| 39| StkId errfunc = restorestack(L, L->errfunc); ------------------ | | 37| 39|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 39|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 812| 39| lua_assert(ttisfunction(s2v(errfunc))); ------------------ | | 114| 39|#define lua_assert(c) ((void)0) ------------------ 813| 39| setobjs2s(L, L->top.p, L->top.p - 1); /* move argument */ ------------------ | | 129| 39|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 39| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 39| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 39|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 39| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 39| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 39|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 39| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 39|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 814| 39| setobjs2s(L, L->top.p - 1, errfunc); /* push function */ ------------------ | | 129| 39|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 39| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 39| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 39|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 39| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 39| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 39|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 39| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 39|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 815| 39| L->top.p++; /* assume EXTRA_STACK */ 816| 39| luaD_callnoyield(L, L->top.p - 2, 1); /* call it */ 817| 39| } 818| 41| luaD_throw(L, LUA_ERRRUN); ------------------ | | 51| 41|#define LUA_ERRRUN 2 ------------------ 819| 41|} luaG_runerror: 822| 41|l_noret luaG_runerror (lua_State *L, const char *fmt, ...) { 823| 41| CallInfo *ci = L->ci; 824| 41| const char *msg; 825| 41| va_list argp; 826| 41| luaC_checkGC(L); /* error message uses memory */ ------------------ | | 172| 41|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 41| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 41|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 1, False: 40] | | | | ------------------ | | | | 169| 41| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 41|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 827| 41| va_start(argp, fmt); 828| 41| msg = luaO_pushvfstring(L, fmt, argp); /* format message */ 829| 41| va_end(argp); 830| 41| if (isLua(ci)) { /* if Lua function, add source:line information */ ------------------ | | 241| 41|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 41|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 39, False: 2] | | ------------------ ------------------ 831| 39| luaG_addinfo(L, msg, ci_func(ci)->p->source, getcurrentline(ci)); ------------------ | | 18| 39|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 604| 39|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 39|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 832| 39| setobjs2s(L, L->top.p - 2, L->top.p - 1); /* remove 'msg' */ ------------------ | | 129| 39|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 39| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 39| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 39|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 39| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 39| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 39|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 39| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 39|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 833| 39| L->top.p--; 834| 39| } 835| 41| luaG_errormsg(L); 836| 41|} luaG_traceexec: 880| 8|int luaG_traceexec (lua_State *L, const Instruction *pc) { 881| 8| CallInfo *ci = L->ci; 882| 8| lu_byte mask = L->hookmask; 883| 8| const Proto *p = ci_func(ci)->p; ------------------ | | 18| 8|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 604| 8|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 8|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 884| 8| int counthook; 885| 8| if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) { /* no hooks? */ ------------------ | | 452| 8|#define LUA_MASKLINE (1 << LUA_HOOKLINE) | | ------------------ | | | | 442| 8|#define LUA_HOOKLINE 2 | | ------------------ ------------------ if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) { /* no hooks? */ ------------------ | | 453| 8|#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) | | ------------------ | | | | 443| 8|#define LUA_HOOKCOUNT 3 | | ------------------ ------------------ | Branch (885:7): [True: 8, False: 0] ------------------ 886| 8| ci->u.l.trap = 0; /* don't need to stop again */ 887| 8| return 0; /* turn off 'trap' */ 888| 8| } 889| 0| pc++; /* reference is always next instruction */ 890| 0| ci->u.l.savedpc = pc; /* save 'pc' */ 891| 0| counthook = (--L->hookcount == 0 && (mask & LUA_MASKCOUNT)); ------------------ | | 453| 0|#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) | | ------------------ | | | | 443| 0|#define LUA_HOOKCOUNT 3 | | ------------------ ------------------ | Branch (891:16): [True: 0, False: 0] | Branch (891:39): [True: 0, False: 0] ------------------ 892| 0| if (counthook) ------------------ | Branch (892:7): [True: 0, False: 0] ------------------ 893| 0| resethookcount(L); /* reset count */ ------------------ | | 21| 0|#define resethookcount(L) (L->hookcount = L->basehookcount) ------------------ 894| 0| else if (!(mask & LUA_MASKLINE)) ------------------ | | 452| 0|#define LUA_MASKLINE (1 << LUA_HOOKLINE) | | ------------------ | | | | 442| 0|#define LUA_HOOKLINE 2 | | ------------------ ------------------ | Branch (894:12): [True: 0, False: 0] ------------------ 895| 0| return 1; /* no line hook and count != 0; nothing to be done now */ 896| 0| if (ci->callstatus & CIST_HOOKYIELD) { /* called hook last time? */ ------------------ | | 216| 0|#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */ ------------------ | Branch (896:7): [True: 0, False: 0] ------------------ 897| 0| ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */ ------------------ | | 216| 0|#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */ ------------------ 898| 0| return 1; /* do not call hook again (VM yielded, so it did not move) */ 899| 0| } 900| 0| if (!isIT(*(ci->u.l.savedpc - 1))) /* top not being used? */ ------------------ | | 396| 0|#define isIT(i) (testITMode(GET_OPCODE(i)) && GETARG_B(i) == 0) | | ------------------ | | | | 386| 0|#define testITMode(m) (luaP_opmodes[m] & (1 << 5)) | | | | ------------------ | | | | | Branch (386:23): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define isIT(i) (testITMode(GET_OPCODE(i)) && GETARG_B(i) == 0) | | ------------------ | | | | 128| 0|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (396:48): [True: 0, False: 0] | | ------------------ ------------------ 901| 0| L->top.p = ci->top.p; /* correct top */ 902| 0| if (counthook) ------------------ | Branch (902:7): [True: 0, False: 0] ------------------ 903| 0| luaD_hook(L, LUA_HOOKCOUNT, -1, 0, 0); /* call count hook */ ------------------ | | 443| 0|#define LUA_HOOKCOUNT 3 ------------------ 904| 0| if (mask & LUA_MASKLINE) { ------------------ | | 452| 0|#define LUA_MASKLINE (1 << LUA_HOOKLINE) | | ------------------ | | | | 442| 0|#define LUA_HOOKLINE 2 | | ------------------ ------------------ | Branch (904:7): [True: 0, False: 0] ------------------ 905| | /* 'L->oldpc' may be invalid; use zero in this case */ 906| 0| int oldpc = (L->oldpc < p->sizecode) ? L->oldpc : 0; ------------------ | Branch (906:17): [True: 0, False: 0] ------------------ 907| 0| int npci = pcRel(pc, p); ------------------ | | 14| 0|#define pcRel(pc, p) (cast_int((pc) - (p)->code) - 1) | | ------------------ | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 908| 0| if (npci <= oldpc || /* call hook when jump back (loop), */ ------------------ | Branch (908:9): [True: 0, False: 0] ------------------ 909| 0| changedline(p, oldpc, npci)) { /* or when enter new line */ ------------------ | Branch (909:9): [True: 0, False: 0] ------------------ 910| 0| int newline = luaG_getfuncline(p, npci); 911| 0| luaD_hook(L, LUA_HOOKLINE, newline, 0, 0); /* call line hook */ ------------------ | | 442| 0|#define LUA_HOOKLINE 2 ------------------ 912| 0| } 913| 0| L->oldpc = npci; /* 'pc' of last call to line hook */ 914| 0| } 915| 0| if (L->status == LUA_YIELD) { /* did hook yield? */ ------------------ | | 50| 0|#define LUA_YIELD 1 ------------------ | Branch (915:7): [True: 0, False: 0] ------------------ 916| 0| if (counthook) ------------------ | Branch (916:9): [True: 0, False: 0] ------------------ 917| 0| L->hookcount = 1; /* undo decrement to zero */ 918| 0| ci->u.l.savedpc--; /* undo increment (resume will increment it again) */ 919| 0| ci->callstatus |= CIST_HOOKYIELD; /* mark that it yielded */ ------------------ | | 216| 0|#define CIST_HOOKYIELD (1<<6) /* last hook called yielded */ ------------------ 920| 0| luaD_throw(L, LUA_YIELD); ------------------ | | 50| 0|#define LUA_YIELD 1 ------------------ 921| 0| } 922| 0| return 1; /* keep 'trap' on */ 923| 0|} ldebug.c:getbaseline: 60| 99|static int getbaseline (const Proto *f, int pc, int *basepc) { 61| 99| if (f->sizeabslineinfo == 0 || pc < f->abslineinfo[0].pc) { ------------------ | Branch (61:7): [True: 34, False: 65] | Branch (61:34): [True: 4, False: 61] ------------------ 62| 38| *basepc = -1; /* start from the beginning */ 63| 38| return f->linedefined; 64| 38| } 65| 61| else { 66| 61| int i = cast_uint(pc) / MAXIWTHABS - 1; /* get an estimate */ ------------------ | | 142| 61|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 61|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ int i = cast_uint(pc) / MAXIWTHABS - 1; /* get an estimate */ ------------------ | | 35| 61|#define MAXIWTHABS 128 ------------------ 67| | /* estimate must be a lower bound of the correct base */ 68| 61| lua_assert(i < 0 || ------------------ | | 114| 61|#define lua_assert(c) ((void)0) ------------------ 69| 61| (i < f->sizeabslineinfo && f->abslineinfo[i].pc <= pc)); 70| 236k| while (i + 1 < f->sizeabslineinfo && pc >= f->abslineinfo[i + 1].pc) ------------------ | Branch (70:12): [True: 236k, False: 53] | Branch (70:42): [True: 236k, False: 8] ------------------ 71| 236k| i++; /* low estimate; adjust it */ 72| 61| *basepc = f->abslineinfo[i].pc; 73| 61| return f->abslineinfo[i].line; 74| 61| } 75| 99|} ldebug.c:currentpc: 41| 153|static int currentpc (CallInfo *ci) { 42| 153| lua_assert(isLua(ci)); ------------------ | | 114| 153|#define lua_assert(c) ((void)0) ------------------ 43| 153| return pcRel(ci->u.l.savedpc, ci_func(ci)->p); ------------------ | | 14| 153|#define pcRel(pc, p) (cast_int((pc) - (p)->code) - 1) | | ------------------ | | | | 141| 153|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 153|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 44| 153|} ldebug.c:auxgetinfo: 328| 120| Closure *f, CallInfo *ci) { 329| 120| int status = 1; 330| 420| for (; *what; what++) { ------------------ | Branch (330:10): [True: 300, False: 120] ------------------ 331| 300| switch (*what) { 332| 60| case 'S': { ------------------ | Branch (332:7): [True: 60, False: 240] ------------------ 333| 60| funcinfo(ar, f); 334| 60| break; 335| 0| } 336| 60| case 'l': { ------------------ | Branch (336:7): [True: 60, False: 240] ------------------ 337| 60| ar->currentline = (ci && isLua(ci)) ? getcurrentline(ci) : -1; ------------------ | | 241| 60|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 60|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 60, False: 0] | | ------------------ ------------------ | Branch (337:28): [True: 60, False: 0] ------------------ 338| 60| break; 339| 0| } 340| 0| case 'u': { ------------------ | Branch (340:7): [True: 0, False: 300] ------------------ 341| 0| ar->nups = (f == NULL) ? 0 : f->c.nupvalues; ------------------ | Branch (341:20): [True: 0, False: 0] ------------------ 342| 0| if (noLuaClosure(f)) { ------------------ | | 34| 0|#define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_VCCL) | | ------------------ | | | | 592| 0|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | | | ------------------ | | | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (34:27): [True: 0, False: 0] | | | Branch (34:42): [True: 0, False: 0] | | ------------------ ------------------ 343| 0| ar->isvararg = 1; 344| 0| ar->nparams = 0; 345| 0| } 346| 0| else { 347| 0| ar->isvararg = f->l.p->is_vararg; 348| 0| ar->nparams = f->l.p->numparams; 349| 0| } 350| 0| break; 351| 0| } 352| 60| case 't': { ------------------ | Branch (352:7): [True: 60, False: 240] ------------------ 353| 60| ar->istailcall = (ci) ? ci->callstatus & CIST_TAIL : 0; ------------------ | | 215| 60|#define CIST_TAIL (1<<5) /* call was tail called */ ------------------ | Branch (353:26): [True: 60, False: 0] ------------------ 354| 60| break; 355| 0| } 356| 60| case 'n': { ------------------ | Branch (356:7): [True: 60, False: 240] ------------------ 357| 60| ar->namewhat = getfuncname(L, ci, &ar->name); 358| 60| if (ar->namewhat == NULL) { ------------------ | Branch (358:13): [True: 39, False: 21] ------------------ 359| 39| ar->namewhat = ""; /* not found */ 360| 39| ar->name = NULL; 361| 39| } 362| 60| break; 363| 0| } 364| 0| case 'r': { ------------------ | Branch (364:7): [True: 0, False: 300] ------------------ 365| 0| if (ci == NULL || !(ci->callstatus & CIST_TRAN)) ------------------ | | 218| 0|#define CIST_TRAN (1<<8) /* 'ci' has transfer information */ ------------------ | Branch (365:13): [True: 0, False: 0] | Branch (365:27): [True: 0, False: 0] ------------------ 366| 0| ar->ftransfer = ar->ntransfer = 0; 367| 0| else { 368| 0| ar->ftransfer = ci->u2.transferinfo.ftransfer; 369| 0| ar->ntransfer = ci->u2.transferinfo.ntransfer; 370| 0| } 371| 0| break; 372| 0| } 373| 0| case 'L': ------------------ | Branch (373:7): [True: 0, False: 300] ------------------ 374| 60| case 'f': /* handled by lua_getinfo */ ------------------ | Branch (374:7): [True: 60, False: 240] ------------------ 375| 60| break; 376| 0| default: status = 0; /* invalid option */ ------------------ | Branch (376:7): [True: 0, False: 300] ------------------ 377| 300| } 378| 300| } 379| 120| return status; 380| 120|} ldebug.c:funcinfo: 256| 60|static void funcinfo (lua_Debug *ar, Closure *cl) { 257| 60| if (noLuaClosure(cl)) { ------------------ | | 34| 60|#define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_VCCL) | | ------------------ | | | | 592| 60|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | | | ------------------ | | | | | | 42| 60|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (34:27): [True: 0, False: 60] | | | Branch (34:42): [True: 0, False: 60] | | ------------------ ------------------ 258| 0| ar->source = "=[C]"; 259| 0| ar->srclen = LL("=[C]"); ------------------ | | 70| 0|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 260| 0| ar->linedefined = -1; 261| 0| ar->lastlinedefined = -1; 262| 0| ar->what = "C"; 263| 0| } 264| 60| else { 265| 60| const Proto *p = cl->l.p; 266| 60| if (p->source) { ------------------ | Branch (266:9): [True: 60, False: 0] ------------------ 267| 60| ar->source = getstr(p->source); ------------------ | | 403| 60|#define getstr(ts) ((ts)->contents) ------------------ 268| 60| ar->srclen = tsslen(p->source); ------------------ | | 410| 60|#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | | 360| 60|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | ------------------ | | | | | | 42| 60|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (410:20): [True: 60, False: 0] | | ------------------ ------------------ 269| 60| } 270| 0| else { 271| 0| ar->source = "=?"; 272| 0| ar->srclen = LL("=?"); ------------------ | | 70| 0|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 273| 0| } 274| 60| ar->linedefined = p->linedefined; 275| 60| ar->lastlinedefined = p->lastlinedefined; 276| 60| ar->what = (ar->linedefined == 0) ? "main" : "Lua"; ------------------ | Branch (276:16): [True: 39, False: 21] ------------------ 277| 60| } 278| 60| luaO_chunkid(ar->short_src, ar->source, ar->srclen); 279| 60|} ldebug.c:getfuncname: 319| 60|static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) { 320| | /* calling function is a known function? */ 321| 60| if (ci != NULL && !(ci->callstatus & CIST_TAIL)) ------------------ | | 215| 60|#define CIST_TAIL (1<<5) /* call was tail called */ ------------------ | Branch (321:7): [True: 60, False: 0] | Branch (321:21): [True: 60, False: 0] ------------------ 322| 60| return funcnamefromcall(L, ci->previous, name); 323| 0| else return NULL; /* no way to find a name */ 324| 60|} ldebug.c:typeerror: 726| 31| const char *extra) { 727| 31| const char *t = luaT_objtypename(L, o); 728| 31| luaG_runerror(L, "attempt to %s a %s value%s", op, t, extra); 729| 31|} ldebug.c:varinfo: 706| 31|static const char *varinfo (lua_State *L, const TValue *o) { 707| 31| CallInfo *ci = L->ci; 708| 31| const char *name = NULL; /* to avoid warnings */ 709| 31| const char *kind = NULL; 710| 31| if (isLua(ci)) { ------------------ | | 241| 31|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 31|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 31, False: 0] | | ------------------ ------------------ 711| 31| kind = getupvalname(ci, o, &name); /* check whether 'o' is an upvalue */ 712| 31| if (!kind) { /* not an upvalue? */ ------------------ | Branch (712:9): [True: 31, False: 0] ------------------ 713| 31| int reg = instack(ci, o); /* try a register */ 714| 31| if (reg >= 0) /* is 'o' a register? */ ------------------ | Branch (714:11): [True: 31, False: 0] ------------------ 715| 31| kind = getobjname(ci_func(ci)->p, currentpc(ci), reg, &name); ------------------ | | 18| 31|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 604| 31|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 31|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 716| 31| } 717| 31| } 718| 31| return formatvarinfo(L, kind, name); 719| 31|} ldebug.c:getupvalname: 681| 31| const char **name) { 682| 31| LClosure *c = ci_func(ci); ------------------ | | 18| 31|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 604| 31|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 31|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 683| 31| int i; 684| 62| for (i = 0; i < c->nupvalues; i++) { ------------------ | Branch (684:15): [True: 31, False: 31] ------------------ 685| 31| if (c->upvals[i]->v.p == o) { ------------------ | Branch (685:9): [True: 0, False: 31] ------------------ 686| 0| *name = upvalname(c->p, i); 687| 0| return "upvalue"; 688| 0| } 689| 31| } 690| 31| return NULL; 691| 31|} ldebug.c:upvalname: 177| 28|static const char *upvalname (const Proto *p, int uv) { 178| 28| TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name); ------------------ | | 115| 28|#define check_exp(c,e) (e) ------------------ 179| 28| if (s == NULL) return "?"; ------------------ | Branch (179:7): [True: 0, False: 28] ------------------ 180| 28| else return getstr(s); ------------------ | | 403| 28|#define getstr(ts) ((ts)->contents) ------------------ 181| 28|} ldebug.c:instack: 664| 31|static int instack (CallInfo *ci, const TValue *o) { 665| 31| int pos; 666| 31| StkId base = ci->func.p + 1; 667| 214| for (pos = 0; base + pos < ci->top.p; pos++) { ------------------ | Branch (667:17): [True: 214, False: 0] ------------------ 668| 214| if (o == s2v(base + pos)) ------------------ | | 172| 214|#define s2v(o) (&(o)->val) ------------------ | Branch (668:9): [True: 31, False: 183] ------------------ 669| 31| return pos; 670| 214| } 671| 0| return -1; /* not found */ 672| 31|} ldebug.c:getobjname: 527| 60| const char **name) { 528| 60| int pc; 529| 60| *name = luaF_getlocalname(p, reg + 1, lastpc); 530| 60| if (*name) /* is a local? */ ------------------ | Branch (530:7): [True: 1, False: 59] ------------------ 531| 1| return "local"; 532| | /* else try symbolic execution */ 533| 59| pc = findsetreg(p, lastpc, reg); 534| 59| if (pc != -1) { /* could find instruction? */ ------------------ | Branch (534:7): [True: 59, False: 0] ------------------ 535| 59| Instruction i = p->code[pc]; 536| 59| OpCode op = GET_OPCODE(i); ------------------ | | 114| 59|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 59|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 537| 59| switch (op) { 538| 0| case OP_MOVE: { ------------------ | Branch (538:7): [True: 0, False: 59] ------------------ 539| 0| int b = GETARG_B(i); /* move from 'b' to 'a' */ ------------------ | | 128| 0|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 540| 0| if (b < GETARG_A(i)) ------------------ | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (540:13): [True: 0, False: 0] ------------------ 541| 0| return getobjname(p, pc, b, name); /* get name for 'b' */ 542| 0| break; 543| 0| } 544| 25| case OP_GETTABUP: { ------------------ | Branch (544:7): [True: 25, False: 34] ------------------ 545| 25| int k = GETARG_C(i); /* key index */ ------------------ | | 132| 25|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 25|#define check_exp(c,e) (e) | | ------------------ ------------------ 546| 25| kname(p, k, name); 547| 25| return gxf(p, pc, i, 1); 548| 0| } 549| 3| case OP_GETTABLE: { ------------------ | Branch (549:7): [True: 3, False: 56] ------------------ 550| 3| int k = GETARG_C(i); /* key index */ ------------------ | | 132| 3|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 3|#define check_exp(c,e) (e) | | ------------------ ------------------ 551| 3| rname(p, pc, k, name); 552| 3| return gxf(p, pc, i, 0); 553| 0| } 554| 0| case OP_GETI: { ------------------ | Branch (554:7): [True: 0, False: 59] ------------------ 555| 0| *name = "integer index"; 556| 0| return "field"; 557| 0| } 558| 1| case OP_GETFIELD: { ------------------ | Branch (558:7): [True: 1, False: 58] ------------------ 559| 1| int k = GETARG_C(i); /* key index */ ------------------ | | 132| 1|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 1|#define check_exp(c,e) (e) | | ------------------ ------------------ 560| 1| kname(p, k, name); 561| 1| return gxf(p, pc, i, 0); 562| 0| } 563| 3| case OP_GETUPVAL: { ------------------ | Branch (563:7): [True: 3, False: 56] ------------------ 564| 3| *name = upvalname(p, GETARG_B(i)); ------------------ | | 128| 3|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 3|#define check_exp(c,e) (e) | | ------------------ ------------------ 565| 3| return "upvalue"; 566| 0| } 567| 25| case OP_LOADK: ------------------ | Branch (567:7): [True: 25, False: 34] ------------------ 568| 25| case OP_LOADKX: { ------------------ | Branch (568:7): [True: 0, False: 59] ------------------ 569| 25| int b = (op == OP_LOADK) ? GETARG_Bx(i) ------------------ | | 140| 25|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 115| 25|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (569:17): [True: 25, False: 0] ------------------ 570| 25| : GETARG_Ax(p->code[pc + 1]); ------------------ | | 143| 0|#define GETARG_Ax(i) check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 571| 25| if (ttisstring(&p->k[b])) { ------------------ | | 363| 25|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 25|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 25|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 25|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 25, False: 0] | | | | ------------------ | | ------------------ ------------------ 572| 25| *name = svalue(&p->k[b]); ------------------ | | 407| 25|#define svalue(o) getstr(tsvalue(o)) | | ------------------ | | | | 403| 25|#define getstr(ts) ((ts)->contents) | | ------------------ ------------------ 573| 25| return "constant"; 574| 25| } 575| 0| break; 576| 25| } 577| 0| case OP_SELF: { ------------------ | Branch (577:7): [True: 0, False: 59] ------------------ 578| 0| rkname(p, pc, i, name); 579| 0| return "method"; 580| 25| } 581| 2| default: break; /* go through to return NULL */ ------------------ | Branch (581:7): [True: 2, False: 57] ------------------ 582| 59| } 583| 59| } 584| 2| return NULL; /* could not find reasonable name */ 585| 59|} ldebug.c:findsetreg: 465| 59|static int findsetreg (const Proto *p, int lastpc, int reg) { 466| 59| int pc; 467| 59| int setreg = -1; /* keep last instruction that changed 'reg' */ 468| 59| int jmptarget = 0; /* any code before this address is conditional */ 469| 59| if (testMMMode(GET_OPCODE(p->code[lastpc]))) ------------------ | | 388| 59|#define testMMMode(m) (luaP_opmodes[m] & (1 << 7)) | | ------------------ | | | Branch (388:23): [True: 17, False: 42] | | ------------------ ------------------ 470| 17| lastpc--; /* previous instruction was not actually executed */ 471| 165k| for (pc = 0; pc < lastpc; pc++) { ------------------ | Branch (471:16): [True: 164k, False: 59] ------------------ 472| 164k| Instruction i = p->code[pc]; 473| 164k| OpCode op = GET_OPCODE(i); ------------------ | | 114| 164k|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 164k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 474| 164k| int a = GETARG_A(i); ------------------ | | 125| 164k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 164k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 164k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 164k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 475| 164k| int change; /* true if current instruction changed 'reg' */ 476| 164k| switch (op) { 477| 339| case OP_LOADNIL: { /* set registers from 'a' to 'a+b' */ ------------------ | Branch (477:7): [True: 339, False: 164k] ------------------ 478| 339| int b = GETARG_B(i); ------------------ | | 128| 339|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 339|#define check_exp(c,e) (e) | | ------------------ ------------------ 479| 339| change = (a <= reg && reg <= a + b); ------------------ | Branch (479:19): [True: 286, False: 53] | Branch (479:31): [True: 10, False: 276] ------------------ 480| 339| break; 481| 0| } 482| 0| case OP_TFORCALL: { /* affect all regs above its base */ ------------------ | Branch (482:7): [True: 0, False: 164k] ------------------ 483| 0| change = (reg >= a + 2); 484| 0| break; 485| 0| } 486| 65.1k| case OP_CALL: ------------------ | Branch (486:7): [True: 65.1k, False: 99.8k] ------------------ 487| 65.1k| case OP_TAILCALL: { /* affect all registers above base */ ------------------ | Branch (487:7): [True: 0, False: 164k] ------------------ 488| 65.1k| change = (reg >= a); 489| 65.1k| break; 490| 65.1k| } 491| 2.34k| case OP_JMP: { /* doesn't change registers, but changes 'jmptarget' */ ------------------ | Branch (491:7): [True: 2.34k, False: 162k] ------------------ 492| 2.34k| int b = GETARG_sJ(i); ------------------ | | 151| 2.34k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | ------------------ | | | | 115| 2.34k|#define check_exp(c,e) (e) | | ------------------ ------------------ 493| 2.34k| int dest = pc + 1 + b; 494| | /* jump does not skip 'lastpc' and is larger than current one? */ 495| 2.34k| if (dest <= lastpc && dest > jmptarget) ------------------ | Branch (495:13): [True: 2.34k, False: 0] | Branch (495:31): [True: 1.34k, False: 997] ------------------ 496| 1.34k| jmptarget = dest; /* update 'jmptarget' */ 497| 2.34k| change = 0; 498| 2.34k| break; 499| 65.1k| } 500| 97.1k| default: /* any instruction that sets A */ ------------------ | Branch (500:7): [True: 97.1k, False: 67.8k] ------------------ 501| 97.1k| change = (testAMode(op) && reg == a); ------------------ | | 384| 194k|#define testAMode(m) (luaP_opmodes[m] & (1 << 3)) | | ------------------ | | | Branch (384:22): [True: 90.7k, False: 6.45k] | | ------------------ ------------------ | Branch (501:36): [True: 469, False: 90.2k] ------------------ 502| 97.1k| break; 503| 164k| } 504| 164k| if (change) ------------------ | Branch (504:9): [True: 498, False: 164k] ------------------ 505| 498| setreg = filterpc(pc, jmptarget); 506| 164k| } 507| 59| return setreg; 508| 59|} ldebug.c:filterpc: 455| 498|static int filterpc (int pc, int jmptarget) { 456| 498| if (pc < jmptarget) /* is code conditional (inside a jump)? */ ------------------ | Branch (456:7): [True: 252, False: 246] ------------------ 457| 252| return -1; /* cannot know who sets that register */ 458| 246| else return pc; /* current position sets that register */ 459| 498|} ldebug.c:kname: 427| 26|static void kname (const Proto *p, int c, const char **name) { 428| 26| TValue *kvalue = &p->k[c]; 429| 26| *name = (ttisstring(kvalue)) ? svalue(kvalue) : "?"; ------------------ | | 363| 26|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 26|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 26|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 26|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ *name = (ttisstring(kvalue)) ? svalue(kvalue) : "?"; ------------------ | | 407| 26|#define svalue(o) getstr(tsvalue(o)) | | ------------------ | | | | 403| 26|#define getstr(ts) ((ts)->contents) | | ------------------ ------------------ | Branch (429:11): [True: 26, False: 0] ------------------ 430| 26|} ldebug.c:gxf: 515| 29|static const char *gxf (const Proto *p, int pc, Instruction i, int isup) { 516| 29| int t = GETARG_B(i); /* table index */ ------------------ | | 128| 29|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 29|#define check_exp(c,e) (e) | | ------------------ ------------------ 517| 29| const char *name; /* name of indexed variable */ 518| 29| if (isup) /* is an upvalue? */ ------------------ | Branch (518:7): [True: 25, False: 4] ------------------ 519| 25| name = upvalname(p, t); 520| 4| else 521| 4| getobjname(p, pc, t, &name); 522| 29| return (name && strcmp(name, LUA_ENV) == 0) ? "global" : "field"; ------------------ | | 24| 29|#define LUA_ENV "_ENV" ------------------ | Branch (522:11): [True: 29, False: 0] | Branch (522:19): [True: 29, False: 0] ------------------ 523| 29|} ldebug.c:rname: 436| 3|static void rname (const Proto *p, int pc, int c, const char **name) { 437| 3| const char *what = getobjname(p, pc, c, name); /* search for 'c' */ 438| 3| if (!(what && *what == 'c')) /* did not find a constant name? */ ------------------ | Branch (438:9): [True: 3, False: 0] | Branch (438:17): [True: 3, False: 0] ------------------ 439| 0| *name = "?"; 440| 3|} ldebug.c:funcnamefromcall: 639| 61| const char **name) { 640| 61| if (ci->callstatus & CIST_HOOKED) { /* was it called inside a hook? */ ------------------ | | 213| 61|#define CIST_HOOKED (1<<3) /* call is running a debug hook */ ------------------ | Branch (640:7): [True: 0, False: 61] ------------------ 641| 0| *name = "?"; 642| 0| return "hook"; 643| 0| } 644| 61| else if (ci->callstatus & CIST_FIN) { /* was it called as a finalizer? */ ------------------ | | 217| 61|#define CIST_FIN (1<<7) /* function "called" a finalizer */ ------------------ | Branch (644:12): [True: 0, False: 61] ------------------ 645| 0| *name = "__gc"; 646| 0| return "metamethod"; /* report it as such */ 647| 0| } 648| 61| else if (isLua(ci)) ------------------ | | 241| 61|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 61|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 22, False: 39] | | ------------------ ------------------ 649| 22| return funcnamefromcode(L, ci_func(ci)->p, currentpc(ci), name); ------------------ | | 18| 22|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 604| 22|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 22|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 650| 39| else 651| 39| return NULL; 652| 61|} ldebug.c:funcnamefromcode: 595| 22| int pc, const char **name) { 596| 22| TMS tm = (TMS)0; /* (initial value avoids warnings) */ 597| 22| Instruction i = p->code[pc]; /* calling instruction */ 598| 22| switch (GET_OPCODE(i)) { ------------------ | | 114| 22|#define GET_OPCODE(i) (cast(OpCode, ((i)>>POS_OP) & MASK1(SIZE_OP,0))) | | ------------------ | | | | 136| 22|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 599| 22| case OP_CALL: ------------------ | Branch (599:5): [True: 22, False: 0] ------------------ 600| 22| case OP_TAILCALL: ------------------ | Branch (600:5): [True: 0, False: 22] ------------------ 601| 22| return getobjname(p, pc, GETARG_A(i), name); /* get function name */ ------------------ | | 125| 22|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 22|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 22|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 22|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 602| 0| case OP_TFORCALL: { /* for iterator */ ------------------ | Branch (602:5): [True: 0, False: 22] ------------------ 603| 0| *name = "for iterator"; 604| 0| return "for iterator"; 605| 22| } 606| | /* other instructions can do calls through metamethods */ 607| 0| case OP_SELF: case OP_GETTABUP: case OP_GETTABLE: ------------------ | Branch (607:5): [True: 0, False: 22] | Branch (607:19): [True: 0, False: 22] | Branch (607:37): [True: 0, False: 22] ------------------ 608| 0| case OP_GETI: case OP_GETFIELD: ------------------ | Branch (608:5): [True: 0, False: 22] | Branch (608:19): [True: 0, False: 22] ------------------ 609| 0| tm = TM_INDEX; 610| 0| break; 611| 0| case OP_SETTABUP: case OP_SETTABLE: case OP_SETI: case OP_SETFIELD: ------------------ | Branch (611:5): [True: 0, False: 22] | Branch (611:23): [True: 0, False: 22] | Branch (611:41): [True: 0, False: 22] | Branch (611:55): [True: 0, False: 22] ------------------ 612| 0| tm = TM_NEWINDEX; 613| 0| break; 614| 0| case OP_MMBIN: case OP_MMBINI: case OP_MMBINK: { ------------------ | Branch (614:5): [True: 0, False: 22] | Branch (614:20): [True: 0, False: 22] | Branch (614:36): [True: 0, False: 22] ------------------ 615| 0| tm = cast(TMS, GETARG_C(i)); ------------------ | | 136| 0|#define cast(t, exp) ((t)(exp)) ------------------ 616| 0| break; 617| 0| } 618| 0| case OP_UNM: tm = TM_UNM; break; ------------------ | Branch (618:5): [True: 0, False: 22] ------------------ 619| 0| case OP_BNOT: tm = TM_BNOT; break; ------------------ | Branch (619:5): [True: 0, False: 22] ------------------ 620| 0| case OP_LEN: tm = TM_LEN; break; ------------------ | Branch (620:5): [True: 0, False: 22] ------------------ 621| 0| case OP_CONCAT: tm = TM_CONCAT; break; ------------------ | Branch (621:5): [True: 0, False: 22] ------------------ 622| 0| case OP_EQ: tm = TM_EQ; break; ------------------ | Branch (622:5): [True: 0, False: 22] ------------------ 623| | /* no cases for OP_EQI and OP_EQK, as they don't call metamethods */ 624| 0| case OP_LT: case OP_LTI: case OP_GTI: tm = TM_LT; break; ------------------ | Branch (624:5): [True: 0, False: 22] | Branch (624:17): [True: 0, False: 22] | Branch (624:30): [True: 0, False: 22] ------------------ 625| 0| case OP_LE: case OP_LEI: case OP_GEI: tm = TM_LE; break; ------------------ | Branch (625:5): [True: 0, False: 22] | Branch (625:17): [True: 0, False: 22] | Branch (625:30): [True: 0, False: 22] ------------------ 626| 0| case OP_CLOSE: case OP_RETURN: tm = TM_CLOSE; break; ------------------ | Branch (626:5): [True: 0, False: 22] | Branch (626:20): [True: 0, False: 22] ------------------ 627| 0| default: ------------------ | Branch (627:5): [True: 0, False: 22] ------------------ 628| 0| return NULL; /* cannot find a reasonable name */ 629| 22| } 630| 0| *name = getstr(G(L)->tmname[tm]) + 2; ------------------ | | 403| 0|#define getstr(ts) ((ts)->contents) ------------------ 631| 0| return "metamethod"; 632| 22|} ldebug.c:formatvarinfo: 695| 31| const char *name) { 696| 31| if (kind == NULL) ------------------ | Branch (696:7): [True: 1, False: 30] ------------------ 697| 1| return ""; /* no information */ 698| 30| else 699| 30| return luaO_pushfstring(L, " (%s '%s')", kind, name); 700| 31|} ldebug.c:getcurrentline: 98| 99|static int getcurrentline (CallInfo *ci) { 99| 99| return luaG_getfuncline(ci_func(ci)->p, currentpc(ci)); ------------------ | | 18| 99|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 604| 99|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 99|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 100| 99|} luaD_seterrorobj: 91| 257|void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) { 92| 257| switch (errcode) { 93| 0| case LUA_ERRMEM: { /* memory error? */ ------------------ | | 53| 0|#define LUA_ERRMEM 4 ------------------ | Branch (93:5): [True: 0, False: 257] ------------------ 94| 0| setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */ ------------------ | | 377| 0|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 0| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 0| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 0| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 95| 0| break; 96| 0| } 97| 0| case LUA_ERRERR: { ------------------ | | 54| 0|#define LUA_ERRERR 5 ------------------ | Branch (97:5): [True: 0, False: 257] ------------------ 98| 0| setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling")); ------------------ | | 377| 0|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 0| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 0| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 0| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 99| 0| break; 100| 0| } 101| 0| case LUA_OK: { /* special case only for closing upvalues */ ------------------ | | 49| 0|#define LUA_OK 0 ------------------ | Branch (101:5): [True: 0, False: 257] ------------------ 102| 0| setnilvalue(s2v(oldtop)); /* no error message */ ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 103| 0| break; 104| 0| } 105| 257| default: { ------------------ | Branch (105:5): [True: 257, False: 0] ------------------ 106| 257| lua_assert(errorstatus(errcode)); /* real error */ ------------------ | | 114| 257|#define lua_assert(c) ((void)0) ------------------ 107| 257| setobjs2s(L, oldtop, L->top.p - 1); /* error message on current top */ ------------------ | | 129| 257|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 257| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 257| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 257|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 257| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 257| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 257|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 257| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 257|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 108| 257| break; 109| 0| } 110| 257| } 111| 257| L->top.p = oldtop + 1; 112| 257|} luaD_throw: 115| 257|l_noret luaD_throw (lua_State *L, int errcode) { 116| 257| if (L->errorJmp) { /* thread has an error handler? */ ------------------ | Branch (116:7): [True: 257, False: 0] ------------------ 117| 257| L->errorJmp->status = errcode; /* set status */ 118| 257| LUAI_THROW(L, L->errorJmp); /* jump to it */ ------------------ | | 66| 257|#define LUAI_THROW(L,c) _longjmp((c)->b, 1) ------------------ 119| 257| } 120| 0| else { /* thread has no error handler */ 121| 0| global_State *g = G(L); ------------------ | | 335| 0|#define G(L) (L->l_G) ------------------ 122| 0| errcode = luaE_resetthread(L, errcode); /* close all upvalues */ 123| 0| if (g->mainthread->errorJmp) { /* main thread has a handler? */ ------------------ | Branch (123:9): [True: 0, False: 0] ------------------ 124| 0| setobjs2s(L, g->mainthread->top.p++, L->top.p - 1); /* copy error obj. */ ------------------ | | 129| 0|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 125| 0| luaD_throw(g->mainthread, errcode); /* re-throw in main thread */ 126| 0| } 127| 0| else { /* no handler at all; abort */ 128| 0| if (g->panic) { /* panic function? */ ------------------ | Branch (128:11): [True: 0, False: 0] ------------------ 129| 0| lua_unlock(L); ------------------ | | 265| 0|#define lua_unlock(L) ((void) 0) ------------------ 130| 0| g->panic(L); /* call panic function (last chance to jump out) */ 131| 0| } 132| 0| abort(); 133| 0| } 134| 0| } 135| 257|} luaD_rawrunprotected: 138| 1.08k|int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) { 139| 1.08k| l_uint32 oldnCcalls = L->nCcalls; 140| 1.08k| struct lua_longjmp lj; 141| 1.08k| lj.status = LUA_OK; ------------------ | | 49| 1.08k|#define LUA_OK 0 ------------------ 142| 1.08k| lj.previous = L->errorJmp; /* chain new error handler */ 143| 1.08k| L->errorJmp = &lj; 144| 1.08k| LUAI_TRY(L, &lj, ------------------ | | 67| 1.08k|#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a } | | ------------------ | | | Branch (67:30): [True: 1.08k, False: 0] | | ------------------ ------------------ 145| 1.08k| (*f)(L, ud); 146| 1.08k| ); 147| 1.08k| L->errorJmp = lj.previous; /* restore old error handler */ 148| 1.08k| L->nCcalls = oldnCcalls; 149| 1.08k| return lj.status; 150| 1.08k|} luaD_reallocstack: 212| 50|int luaD_reallocstack (lua_State *L, int newsize, int raiseerror) { 213| 50| int oldsize = stacksize(L); ------------------ | | 147| 50|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 50|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 50|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 214| 50| int i; 215| 50| StkId newstack; 216| 50| int oldgcstop = G(L)->gcstopem; ------------------ | | 335| 50|#define G(L) (L->l_G) ------------------ 217| 50| lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE); ------------------ | | 114| 50|#define lua_assert(c) ((void)0) ------------------ 218| 50| relstack(L); /* change pointers to offsets */ 219| 50| G(L)->gcstopem = 1; /* stop emergency collection */ ------------------ | | 335| 50|#define G(L) (L->l_G) ------------------ 220| 50| newstack = luaM_reallocvector(L, L->stack.p, oldsize + EXTRA_STACK, ------------------ | | 71| 50| (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \ | | ------------------ | | | | 136| 50|#define cast(t, exp) ((t)(exp)) | | ------------------ | | 72| 50| cast_sizet(n) * sizeof(t)))) ------------------ 221| 50| newsize + EXTRA_STACK, StackValue); 222| 50| G(L)->gcstopem = oldgcstop; /* restore emergency collection */ ------------------ | | 335| 50|#define G(L) (L->l_G) ------------------ 223| 50| if (l_unlikely(newstack == NULL)) { /* reallocation failed? */ ------------------ | | 688| 50|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 50|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 50] | | | | ------------------ | | ------------------ ------------------ 224| 0| correctstack(L); /* change offsets back to pointers */ 225| 0| if (raiseerror) ------------------ | Branch (225:9): [True: 0, False: 0] ------------------ 226| 0| luaM_error(L); ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 53| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 227| 0| else return 0; /* do not raise an error */ 228| 0| } 229| 50| L->stack.p = newstack; 230| 50| correctstack(L); /* change offsets back to pointers */ 231| 50| L->stack_last.p = L->stack.p + newsize; 232| 1.00M| for (i = oldsize + EXTRA_STACK; i < newsize + EXTRA_STACK; i++) ------------------ | | 142| 50|#define EXTRA_STACK 5 ------------------ for (i = oldsize + EXTRA_STACK; i < newsize + EXTRA_STACK; i++) ------------------ | | 142| 1.00M|#define EXTRA_STACK 5 ------------------ | Branch (232:35): [True: 1.00M, False: 50] ------------------ 233| 1.00M| setnilvalue(s2v(newstack + i)); /* erase new segment */ ------------------ | | 200| 1.00M|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 1.00M|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 234| 50| return 1; 235| 50|} luaD_growstack: 242| 35|int luaD_growstack (lua_State *L, int n, int raiseerror) { 243| 35| int size = stacksize(L); ------------------ | | 147| 35|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 35|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 35|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 244| 35| if (l_unlikely(size > LUAI_MAXSTACK)) { ------------------ | | 688| 35|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 35|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 35] | | | | ------------------ | | ------------------ ------------------ 245| | /* if stack is larger than maximum, thread is already using the 246| | extra space reserved for errors, that is, thread is handling 247| | a stack error; cannot grow further than that. */ 248| 0| lua_assert(stacksize(L) == ERRORSTACKSIZE); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 249| 0| if (raiseerror) ------------------ | Branch (249:9): [True: 0, False: 0] ------------------ 250| 0| luaD_throw(L, LUA_ERRERR); /* error inside message handler */ ------------------ | | 54| 0|#define LUA_ERRERR 5 ------------------ 251| 0| return 0; /* if not 'raiseerror', just signal it */ 252| 0| } 253| 35| else if (n < LUAI_MAXSTACK) { /* avoids arithmetic overflows */ ------------------ | | 740| 35|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (253:12): [True: 35, False: 0] ------------------ 254| 35| int newsize = 2 * size; /* tentative new size */ 255| 35| int needed = cast_int(L->top.p - L->stack.p) + n; ------------------ | | 141| 35|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 35|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 256| 35| if (newsize > LUAI_MAXSTACK) /* cannot cross the limit */ ------------------ | | 740| 35|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (256:9): [True: 2, False: 33] ------------------ 257| 2| newsize = LUAI_MAXSTACK; ------------------ | | 740| 2|#define LUAI_MAXSTACK 1000000 ------------------ 258| 35| if (newsize < needed) /* but must respect what was asked for */ ------------------ | Branch (258:9): [True: 3, False: 32] ------------------ 259| 3| newsize = needed; 260| 35| if (l_likely(newsize <= LUAI_MAXSTACK)) ------------------ | | 687| 35|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 675| 35|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (675:25): [True: 34, False: 1] | | | | ------------------ | | ------------------ ------------------ 261| 34| return luaD_reallocstack(L, newsize, raiseerror); 262| 35| } 263| | /* else stack overflow */ 264| | /* add extra size to be able to handle the error message */ 265| 1| luaD_reallocstack(L, ERRORSTACKSIZE, raiseerror); ------------------ | | 199| 1|#define ERRORSTACKSIZE (LUAI_MAXSTACK + 200) | | ------------------ | | | | 740| 1|#define LUAI_MAXSTACK 1000000 | | ------------------ ------------------ 266| 1| if (raiseerror) ------------------ | Branch (266:7): [True: 1, False: 0] ------------------ 267| 1| luaG_runerror(L, "stack overflow"); 268| 0| return 0; 269| 1|} luaD_shrinkstack: 300| 1.26k|void luaD_shrinkstack (lua_State *L) { 301| 1.26k| int inuse = stackinuse(L); 302| 1.26k| int max = (inuse > LUAI_MAXSTACK / 3) ? LUAI_MAXSTACK : inuse * 3; ------------------ | | 740| 1.26k|#define LUAI_MAXSTACK 1000000 ------------------ int max = (inuse > LUAI_MAXSTACK / 3) ? LUAI_MAXSTACK : inuse * 3; ------------------ | | 740| 1|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (302:13): [True: 1, False: 1.26k] ------------------ 303| | /* if thread is currently not handling a stack overflow and its 304| | size is larger than maximum "reasonable" size, shrink it */ 305| 1.26k| if (inuse <= LUAI_MAXSTACK && stacksize(L) > max) { ------------------ | | 740| 2.52k|#define LUAI_MAXSTACK 1000000 ------------------ if (inuse <= LUAI_MAXSTACK && stacksize(L) > max) { ------------------ | | 147| 1.26k|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 1.26k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 1.26k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (305:7): [True: 1.26k, False: 0] | Branch (305:33): [True: 15, False: 1.24k] ------------------ 306| 15| int nsize = (inuse > LUAI_MAXSTACK / 2) ? LUAI_MAXSTACK : inuse * 2; ------------------ | | 740| 15|#define LUAI_MAXSTACK 1000000 ------------------ int nsize = (inuse > LUAI_MAXSTACK / 2) ? LUAI_MAXSTACK : inuse * 2; ------------------ | | 740| 0|#define LUAI_MAXSTACK 1000000 ------------------ | Branch (306:17): [True: 0, False: 15] ------------------ 307| 15| luaD_reallocstack(L, nsize, 0); /* ok if that fails */ 308| 15| } 309| 1.24k| else /* don't change stack */ 310| 1.24k| condmovestack(L,{},{}); /* (change only for debugging) */ ------------------ | | 366| 1.24k|#define condmovestack(L,pre,pos) ((void)0) ------------------ 311| 1.26k| luaE_shrinkCI(L); /* shrink CI list */ 312| 1.26k|} luaD_inctop: 315| 516|void luaD_inctop (lua_State *L) { 316| 516| luaD_checkstack(L, 1); ------------------ | | 32| 516|#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0) | | ------------------ | | | | 27| 516| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 688| 516|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 516|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 516] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 516| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 516| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 516|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 317| 516| L->top.p++; 318| 516|} luaD_hookcall: 369| 2|void luaD_hookcall (lua_State *L, CallInfo *ci) { 370| 2| L->oldpc = 0; /* set 'oldpc' for new function */ 371| 2| if (L->hookmask & LUA_MASKCALL) { /* is call hook on? */ ------------------ | | 450| 2|#define LUA_MASKCALL (1 << LUA_HOOKCALL) | | ------------------ | | | | 440| 2|#define LUA_HOOKCALL 0 | | ------------------ ------------------ | Branch (371:7): [True: 0, False: 2] ------------------ 372| 0| int event = (ci->callstatus & CIST_TAIL) ? LUA_HOOKTAILCALL ------------------ | | 215| 0|#define CIST_TAIL (1<<5) /* call was tail called */ ------------------ int event = (ci->callstatus & CIST_TAIL) ? LUA_HOOKTAILCALL ------------------ | | 444| 0|#define LUA_HOOKTAILCALL 4 ------------------ | Branch (372:17): [True: 0, False: 0] ------------------ 373| 0| : LUA_HOOKCALL; ------------------ | | 440| 0|#define LUA_HOOKCALL 0 ------------------ 374| 0| Proto *p = ci_func(ci)->p; ------------------ | | 18| 0|#define ci_func(ci) (clLvalue(s2v((ci)->func.p))) | | ------------------ | | | | 604| 0|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 375| 0| ci->u.l.savedpc++; /* hooks assume 'pc' is already incremented */ 376| 0| luaD_hook(L, event, -1, 1, p->numparams); 377| 0| ci->u.l.savedpc--; /* correct 'pc' */ 378| 0| } 379| 2|} luaD_tryfuncTM: 412| 1|StkId luaD_tryfuncTM (lua_State *L, StkId func) { 413| 1| const TValue *tm; 414| 1| StkId p; 415| 1| checkstackGCp(L, 1, func); /* space for metamethod */ ------------------ | | 49| 1| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 1| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 688| 1|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 1|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 1| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | ------------------ | | | | | Branch (28:6): [True: 0, False: 0] | | | | ------------------ | | | | 29| 1| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 1|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 50| 1| ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ | | 51| 1| luaC_checkGC(L), /* stack grow uses memory */ \ | | 52| 1| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 416| 1| tm = luaT_gettmbyobj(L, s2v(func), TM_CALL); /* (after previous GC) */ ------------------ | | 172| 1|#define s2v(o) (&(o)->val) ------------------ 417| 1| if (l_unlikely(ttisnil(tm))) ------------------ | | 688| 1|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 1|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 1, False: 0] | | | | ------------------ | | ------------------ ------------------ 418| 1| luaG_callerror(L, s2v(func)); /* nothing to call */ ------------------ | | 172| 1|#define s2v(o) (&(o)->val) ------------------ 419| 0| for (p = L->top.p; p > func; p--) /* open space for metamethod */ ------------------ | Branch (419:22): [True: 0, False: 0] ------------------ 420| 0| setobjs2s(L, p, p-1); ------------------ | | 129| 0|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 421| 0| L->top.p++; /* stack space pre-allocated by the caller */ 422| 0| setobj2s(L, func, tm); /* metamethod is the new function to be called */ ------------------ | | 131| 0|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 423| 0| return func; 424| 1|} luaD_poscall: 485| 63|void luaD_poscall (lua_State *L, CallInfo *ci, int nres) { 486| 63| int wanted = ci->nresults; 487| 63| if (l_unlikely(L->hookmask && !hastocloseCfunc(wanted))) ------------------ | | 688| 63|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 63|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 63] | | | | | Branch (676:46): [True: 0, False: 63] | | | | | Branch (676:46): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 488| 0| rethook(L, ci, nres); 489| | /* move results to proper place */ 490| 63| moveresults(L, ci->func.p, nres, wanted); 491| | /* function cannot be in any of these cases when returning */ 492| 63| lua_assert(!(ci->callstatus & ------------------ | | 114| 63|#define lua_assert(c) ((void)0) ------------------ 493| 63| (CIST_HOOKED | CIST_YPCALL | CIST_FIN | CIST_TRAN | CIST_CLSRET))); 494| 63| L->ci = ci->previous; /* back to caller (after closing variables) */ 495| 63|} luaD_pretailcall: 544| 16| int narg1, int delta) { 545| 16| retry: 546| 16| switch (ttypetag(s2v(func))) { ------------------ | | 84| 16|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 16|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 547| 0| case LUA_VCCL: /* C closure */ ------------------ | | 592| 0|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (547:5): [True: 0, False: 16] ------------------ 548| 0| return precallC(L, func, LUA_MULTRET, clCvalue(s2v(func))->f); ------------------ | | 36| 0|#define LUA_MULTRET (-1) ------------------ return precallC(L, func, LUA_MULTRET, clCvalue(s2v(func))->f); ------------------ | | 606| 0|#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 549| 0| case LUA_VLCF: /* light C function */ ------------------ | | 591| 0|#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (549:5): [True: 0, False: 16] ------------------ 550| 0| return precallC(L, func, LUA_MULTRET, fvalue(s2v(func))); ------------------ | | 36| 0|#define LUA_MULTRET (-1) ------------------ return precallC(L, func, LUA_MULTRET, fvalue(s2v(func))); ------------------ | | 605| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 551| 16| case LUA_VLCL: { /* Lua function */ ------------------ | | 590| 16|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 16|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (551:5): [True: 16, False: 0] ------------------ 552| 16| Proto *p = clLvalue(s2v(func))->p; ------------------ | | 604| 16|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ 553| 16| int fsize = p->maxstacksize; /* frame size */ 554| 16| int nfixparams = p->numparams; 555| 16| int i; 556| 16| checkstackGCp(L, fsize - delta, func); ------------------ | | 49| 16| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 16| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 688| 16|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 16|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 16] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 16| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | ------------------ | | | | | Branch (28:6): [True: 0, False: 0] | | | | ------------------ | | | | 29| 16| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 16|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 50| 16| ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ | | 51| 16| luaC_checkGC(L), /* stack grow uses memory */ \ | | 52| 16| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 557| 16| ci->func.p -= delta; /* restore 'func' (if vararg) */ 558| 48| for (i = 0; i < narg1; i++) /* move down function and arguments */ ------------------ | Branch (558:19): [True: 32, False: 16] ------------------ 559| 32| setobjs2s(L, ci->func.p + i, func + i); ------------------ | | 129| 32|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 48| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 48| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 32|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 48| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 32| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 32|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 32| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 32|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 560| 16| func = ci->func.p; /* moved-down function */ 561| 16| for (; narg1 <= nfixparams; narg1++) ------------------ | Branch (561:14): [True: 0, False: 16] ------------------ 562| 16| setnilvalue(s2v(func + narg1)); /* complete missing arguments */ ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 563| 16| ci->top.p = func + 1 + fsize; /* top for new function */ 564| 16| lua_assert(ci->top.p <= L->stack_last.p); ------------------ | | 114| 16|#define lua_assert(c) ((void)0) ------------------ 565| 16| ci->u.l.savedpc = p->code; /* starting point */ 566| 16| ci->callstatus |= CIST_TAIL; ------------------ | | 215| 16|#define CIST_TAIL (1<<5) /* call was tail called */ ------------------ 567| 16| L->top.p = func + narg1; /* set top */ 568| 16| return -1; 569| 0| } 570| 0| default: { /* not a function */ ------------------ | Branch (570:5): [True: 0, False: 16] ------------------ 571| 0| func = luaD_tryfuncTM(L, func); /* try to get '__call' metamethod */ 572| | /* return luaD_pretailcall(L, ci, func, narg1 + 1, delta); */ 573| 0| narg1++; 574| 0| goto retry; /* try again */ 575| 0| } 576| 16| } 577| 16|} luaD_precall: 588| 19.8k|CallInfo *luaD_precall (lua_State *L, StkId func, int nresults) { 589| 19.8k| retry: 590| 19.8k| switch (ttypetag(s2v(func))) { ------------------ | | 84| 19.8k|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 19.8k|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 591| 0| case LUA_VCCL: /* C closure */ ------------------ | | 592| 0|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (591:5): [True: 0, False: 19.8k] ------------------ 592| 0| precallC(L, func, nresults, clCvalue(s2v(func))->f); ------------------ | | 606| 0|#define clCvalue(o) check_exp(ttisCclosure(o), gco2ccl(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 593| 0| return NULL; 594| 61| case LUA_VLCF: /* light C function */ ------------------ | | 591| 61|#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */ | | ------------------ | | | | 42| 61|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (594:5): [True: 61, False: 19.7k] ------------------ 595| 61| precallC(L, func, nresults, fvalue(s2v(func))); ------------------ | | 605| 61|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 115| 61|#define check_exp(c,e) (e) | | ------------------ ------------------ 596| 61| return NULL; 597| 19.7k| case LUA_VLCL: { /* Lua function */ ------------------ | | 590| 19.7k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 19.7k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (597:5): [True: 19.7k, False: 62] ------------------ 598| 19.7k| CallInfo *ci; 599| 19.7k| Proto *p = clLvalue(s2v(func))->p; ------------------ | | 604| 19.7k|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | ------------------ | | | | 115| 19.7k|#define check_exp(c,e) (e) | | ------------------ ------------------ 600| 19.7k| int narg = cast_int(L->top.p - func) - 1; /* number of real arguments */ ------------------ | | 141| 19.7k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 19.7k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 601| 19.7k| int nfixparams = p->numparams; 602| 19.7k| int fsize = p->maxstacksize; /* frame size */ 603| 19.7k| checkstackGCp(L, fsize, func); ------------------ | | 49| 19.7k| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 19.7k| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 688| 19.7k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 19.7k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 14, False: 19.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 19.7k| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | ------------------ | | | | | Branch (28:6): [True: 2, False: 12] | | | | ------------------ | | | | 29| 19.7k| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 19.7k|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 50| 19.7k| ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ | | 51| 19.7k| luaC_checkGC(L), /* stack grow uses memory */ \ | | 52| 19.7k| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 604| 19.7k| L->ci = ci = prepCallInfo(L, func, nresults, 0, func + 1 + fsize); 605| 19.7k| ci->u.l.savedpc = p->code; /* starting point */ 606| 19.7k| for (; narg < nfixparams; narg++) ------------------ | Branch (606:14): [True: 2, False: 19.7k] ------------------ 607| 19.7k| setnilvalue(s2v(L->top.p++)); /* complete missing arguments */ ------------------ | | 200| 2|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 19.7k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 608| 19.7k| lua_assert(ci->top.p <= L->stack_last.p); ------------------ | | 114| 19.7k|#define lua_assert(c) ((void)0) ------------------ 609| 19.7k| return ci; 610| 0| } 611| 1| default: { /* not a function */ ------------------ | Branch (611:5): [True: 1, False: 19.8k] ------------------ 612| 1| func = luaD_tryfuncTM(L, func); /* try to get '__call' metamethod */ 613| | /* return luaD_precall(L, func, nresults); */ 614| 1| goto retry; /* try again with metamethod */ 615| 0| } 616| 19.8k| } 617| 19.8k|} luaD_callnoyield: 654| 101|void luaD_callnoyield (lua_State *L, StkId func, int nResults) { 655| 101| ccall(L, func, nResults, nyci); ------------------ | | 117| 101|#define nyci (0x10000 | 1) ------------------ 656| 101|} luaD_closeprotected: 924| 515|int luaD_closeprotected (lua_State *L, ptrdiff_t level, int status) { 925| 515| CallInfo *old_ci = L->ci; 926| 515| lu_byte old_allowhooks = L->allowhook; 927| 515| for (;;) { /* keep closing upvalues until no more errors */ 928| 515| struct CloseP pcl; 929| 515| pcl.level = restorestack(L, level); pcl.status = status; ------------------ | | 37| 515|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 515|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 930| 515| status = luaD_rawrunprotected(L, &closepaux, &pcl); 931| 515| if (l_likely(status == LUA_OK)) /* no more errors? */ ------------------ | | 687| 515|#define l_likely(x) luai_likely(x) | | ------------------ | | | | 675| 515|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | ------------------ | | | | | Branch (675:25): [True: 515, False: 0] | | | | ------------------ | | ------------------ ------------------ 932| 515| return pcl.status; 933| 0| else { /* an error occurred; restore saved state and repeat */ 934| 0| L->ci = old_ci; 935| 0| L->allowhook = old_allowhooks; 936| 0| } 937| 515| } 938| 515|} luaD_pcall: 947| 309| ptrdiff_t old_top, ptrdiff_t ef) { 948| 309| int status; 949| 309| CallInfo *old_ci = L->ci; 950| 309| lu_byte old_allowhooks = L->allowhook; 951| 309| ptrdiff_t old_errfunc = L->errfunc; 952| 309| L->errfunc = ef; 953| 309| status = luaD_rawrunprotected(L, func, u); 954| 309| if (l_unlikely(status != LUA_OK)) { /* an error occurred? */ ------------------ | | 688| 309|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 309|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 257, False: 52] | | | | ------------------ | | ------------------ ------------------ 955| 257| L->ci = old_ci; 956| 257| L->allowhook = old_allowhooks; 957| 257| status = luaD_closeprotected(L, old_top, status); 958| 257| luaD_seterrorobj(L, status, restorestack(L, old_top)); ------------------ | | 37| 257|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 257|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 959| 257| luaD_shrinkstack(L); /* restore stack size in case of overflow */ 960| 257| } 961| 309| L->errfunc = old_errfunc; 962| 309| return status; 963| 309|} luaD_protectedparser: 1006| 258| const char *mode) { 1007| 258| struct SParser p; 1008| 258| int status; 1009| 258| incnny(L); /* cannot yield during parsing */ ------------------ | | 111| 258|#define incnny(L) ((L)->nCcalls += 0x10000) ------------------ 1010| 258| p.z = z; p.name = name; p.mode = mode; 1011| 258| p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0; 1012| 258| p.dyd.gt.arr = NULL; p.dyd.gt.size = 0; 1013| 258| p.dyd.label.arr = NULL; p.dyd.label.size = 0; 1014| 258| luaZ_initbuffer(L, &p.buff); ------------------ | | 29| 258|#define luaZ_initbuffer(L, buff) ((buff)->buffer = NULL, (buff)->buffsize = 0) ------------------ 1015| 258| status = luaD_pcall(L, f_parser, &p, savestack(L, L->top.p), L->errfunc); ------------------ | | 36| 258|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 258|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 258|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1016| 258| luaZ_freebuffer(L, &p.buff); ------------------ | | 44| 258|#define luaZ_freebuffer(L, buff) luaZ_resizebuffer(L, buff, 0) | | ------------------ | | | | 40| 258| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | | | ------------------ | | | | | | 53| 258| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | | | ------------------ | | | | | | | | 146| 258|#define cast_charp(i) cast(char *, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 41| 258| (buff)->buffsize, size), \ | | | | 42| 258| (buff)->buffsize = size) | | ------------------ ------------------ 1017| 258| luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size); ------------------ | | 57| 258|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1018| 258| luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size); ------------------ | | 57| 258|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1019| 258| luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size); ------------------ | | 57| 258|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 1020| 258| decnny(L); ------------------ | | 114| 258|#define decnny(L) ((L)->nCcalls -= 0x10000) ------------------ 1021| 258| return status; 1022| 258|} ldo.c:relstack: 165| 50|static void relstack (lua_State *L) { 166| 50| CallInfo *ci; 167| 50| UpVal *up; 168| 50| L->top.offset = savestack(L, L->top.p); ------------------ | | 36| 50|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 50|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 50|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 50|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 50|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 169| 50| L->tbclist.offset = savestack(L, L->tbclist.p); ------------------ | | 36| 50|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 50|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 50|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 50|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 50|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 170| 58| for (up = L->openupval; up != NULL; up = up->u.open.next) ------------------ | Branch (170:27): [True: 8, False: 50] ------------------ 171| 8| up->v.offset = savestack(L, uplevel(up)); ------------------ | | 36| 8|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 8|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 8|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 8|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 8|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 172| 5.26k| for (ci = L->ci; ci != NULL; ci = ci->previous) { ------------------ | Branch (172:20): [True: 5.21k, False: 50] ------------------ 173| 5.21k| ci->top.offset = savestack(L, ci->top.p); ------------------ | | 36| 5.21k|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 5.21k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 5.21k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 5.21k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 5.21k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 174| 5.21k| ci->func.offset = savestack(L, ci->func.p); ------------------ | | 36| 5.21k|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 5.21k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 5.21k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 5.21k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 5.21k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 175| 5.21k| } 176| 50|} ldo.c:correctstack: 182| 50|static void correctstack (lua_State *L) { 183| 50| CallInfo *ci; 184| 50| UpVal *up; 185| 50| L->top.p = restorestack(L, L->top.offset); ------------------ | | 37| 50|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 50|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 186| 50| L->tbclist.p = restorestack(L, L->tbclist.offset); ------------------ | | 37| 50|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 50|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 187| 58| for (up = L->openupval; up != NULL; up = up->u.open.next) ------------------ | Branch (187:27): [True: 8, False: 50] ------------------ 188| 8| up->v.p = s2v(restorestack(L, up->v.offset)); ------------------ | | 172| 8|#define s2v(o) (&(o)->val) ------------------ 189| 5.26k| for (ci = L->ci; ci != NULL; ci = ci->previous) { ------------------ | Branch (189:20): [True: 5.21k, False: 50] ------------------ 190| 5.21k| ci->top.p = restorestack(L, ci->top.offset); ------------------ | | 37| 5.21k|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 5.21k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 191| 5.21k| ci->func.p = restorestack(L, ci->func.offset); ------------------ | | 37| 5.21k|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 5.21k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 192| 5.21k| if (isLua(ci)) ------------------ | | 241| 5.21k|#define isLua(ci) (!((ci)->callstatus & CIST_C)) | | ------------------ | | | | 211| 5.21k|#define CIST_C (1<<1) /* call is running a C function */ | | ------------------ | | | Branch (241:19): [True: 5.16k, False: 50] | | ------------------ ------------------ 193| 5.16k| ci->u.l.trap = 1; /* signal to update 'trap' in 'luaV_execute' */ 194| 5.21k| } 195| 50|} ldo.c:stackinuse: 276| 1.26k|static int stackinuse (lua_State *L) { 277| 1.26k| CallInfo *ci; 278| 1.26k| int res; 279| 1.26k| StkId lim = L->top.p; 280| 4.09k| for (ci = L->ci; ci != NULL; ci = ci->previous) { ------------------ | Branch (280:20): [True: 2.83k, False: 1.26k] ------------------ 281| 2.83k| if (lim < ci->top.p) lim = ci->top.p; ------------------ | Branch (281:9): [True: 1.26k, False: 1.57k] ------------------ 282| 2.83k| } 283| 1.26k| lua_assert(lim <= L->stack_last.p + EXTRA_STACK); ------------------ | | 114| 1.26k|#define lua_assert(c) ((void)0) ------------------ 284| 1.26k| res = cast_int(lim - L->stack.p) + 1; /* part of stack in use */ ------------------ | | 141| 1.26k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 1.26k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 285| 1.26k| if (res < LUA_MINSTACK) ------------------ | | 80| 1.26k|#define LUA_MINSTACK 20 ------------------ | Branch (285:7): [True: 0, False: 1.26k] ------------------ 286| 0| res = LUA_MINSTACK; /* ensure a minimum size */ ------------------ | | 80| 0|#define LUA_MINSTACK 20 ------------------ 287| 1.26k| return res; 288| 1.26k|} ldo.c:moveresults: 433| 63|l_sinline void moveresults (lua_State *L, StkId res, int nres, int wanted) { 434| 63| StkId firstresult; 435| 63| int i; 436| 63| switch (wanted) { /* handle typical cases separately */ 437| 23| case 0: /* no values needed */ ------------------ | Branch (437:5): [True: 23, False: 40] ------------------ 438| 23| L->top.p = res; 439| 23| return; 440| 29| case 1: /* one value needed */ ------------------ | Branch (440:5): [True: 29, False: 34] ------------------ 441| 29| if (nres == 0) /* no results? */ ------------------ | Branch (441:11): [True: 1, False: 28] ------------------ 442| 29| setnilvalue(s2v(res)); /* adjust with nil */ ------------------ | | 200| 1|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 1|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 443| 28| else /* at least one result */ 444| 29| setobjs2s(L, res, L->top.p - nres); /* move it to proper place */ ------------------ | | 129| 28|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 28| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 28| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 28|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 28| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 28| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 28|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 28| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 28|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 445| 29| L->top.p = res + 1; 446| 29| return; 447| 0| case LUA_MULTRET: ------------------ | | 36| 0|#define LUA_MULTRET (-1) ------------------ | Branch (447:5): [True: 0, False: 63] ------------------ 448| 0| wanted = nres; /* we want all results */ 449| 0| break; 450| 11| default: /* two/more results and/or to-be-closed variables */ ------------------ | Branch (450:5): [True: 11, False: 52] ------------------ 451| 11| if (hastocloseCfunc(wanted)) { /* to-be-closed variables? */ ------------------ | | 46| 11|#define hastocloseCfunc(n) ((n) < LUA_MULTRET) | | ------------------ | | | | 36| 11|#define LUA_MULTRET (-1) | | ------------------ | | | Branch (46:28): [True: 11, False: 0] | | ------------------ ------------------ 452| 11| L->ci->callstatus |= CIST_CLSRET; /* in case of yields */ ------------------ | | 219| 11|#define CIST_CLSRET (1<<9) /* function is closing tbc variables */ ------------------ 453| 11| L->ci->u2.nres = nres; 454| 11| res = luaF_close(L, res, CLOSEKTOP, 1); ------------------ | | 47| 11|#define CLOSEKTOP (-1) ------------------ 455| 11| L->ci->callstatus &= ~CIST_CLSRET; ------------------ | | 219| 11|#define CIST_CLSRET (1<<9) /* function is closing tbc variables */ ------------------ 456| 11| if (L->hookmask) { /* if needed, call hook after '__close's */ ------------------ | Branch (456:13): [True: 0, False: 11] ------------------ 457| 0| ptrdiff_t savedres = savestack(L, res); ------------------ | | 36| 0|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 0|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 0|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 458| 0| rethook(L, L->ci, nres); 459| 0| res = restorestack(L, savedres); /* hook can move stack */ ------------------ | | 37| 0|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 460| 0| } 461| 11| wanted = decodeNresults(wanted); ------------------ | | 50| 11|#define decodeNresults(n) (-(n) - 3) ------------------ 462| 11| if (wanted == LUA_MULTRET) ------------------ | | 36| 11|#define LUA_MULTRET (-1) ------------------ | Branch (462:13): [True: 0, False: 11] ------------------ 463| 0| wanted = nres; /* we want all results */ 464| 11| } 465| 11| break; 466| 63| } 467| | /* generic case */ 468| 11| firstresult = L->top.p - nres; /* index of first result */ 469| 11| if (nres > wanted) /* extra results? */ ------------------ | Branch (469:7): [True: 0, False: 11] ------------------ 470| 0| nres = wanted; /* don't need them */ 471| 22| for (i = 0; i < nres; i++) /* move all results to correct place */ ------------------ | Branch (471:15): [True: 11, False: 11] ------------------ 472| 11| setobjs2s(L, res + i, firstresult + i); ------------------ | | 129| 11|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 22| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 22| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 11|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 22| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 11| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 11|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 11| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 473| 11| for (; i < wanted; i++) /* complete wanted number of results */ ------------------ | Branch (473:10): [True: 0, False: 11] ------------------ 474| 11| setnilvalue(s2v(res + i)); ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 11|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 475| 11| L->top.p = res + wanted; /* top points after the last result */ 476| 11|} ldo.c:precallC: 517| 61| lua_CFunction f) { 518| 61| int n; /* number of returns */ 519| 61| CallInfo *ci; 520| 61| checkstackGCp(L, LUA_MINSTACK, func); /* ensure minimum stack size */ ------------------ | | 49| 61| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 61| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 688| 61|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 61|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 12, False: 49] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 61| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | ------------------ | | | | | Branch (28:6): [True: 0, False: 12] | | | | ------------------ | | | | 29| 61| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 49|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 50| 61| ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ | | 51| 61| luaC_checkGC(L), /* stack grow uses memory */ \ | | 52| 61| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 521| 61| L->ci = ci = prepCallInfo(L, func, nresults, CIST_C, ------------------ | | 211| 61|#define CIST_C (1<<1) /* call is running a C function */ ------------------ 522| 61| L->top.p + LUA_MINSTACK); ------------------ | | 80| 61|#define LUA_MINSTACK 20 ------------------ 523| 61| lua_assert(ci->top.p <= L->stack_last.p); ------------------ | | 114| 61|#define lua_assert(c) ((void)0) ------------------ 524| 61| if (l_unlikely(L->hookmask & LUA_MASKCALL)) { ------------------ | | 688| 61|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 61|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 61] | | | | ------------------ | | ------------------ ------------------ 525| 0| int narg = cast_int(L->top.p - func) - 1; ------------------ | | 141| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 526| 0| luaD_hook(L, LUA_HOOKCALL, -1, 1, narg); ------------------ | | 440| 0|#define LUA_HOOKCALL 0 ------------------ 527| 0| } 528| 61| lua_unlock(L); ------------------ | | 265| 61|#define lua_unlock(L) ((void) 0) ------------------ 529| 61| n = (*f)(L); /* do the actual call */ 530| 61| lua_lock(L); ------------------ | | 264| 61|#define lua_lock(L) ((void) 0) ------------------ 531| 61| api_checknelems(L, n); ------------------ | | 33| 61| api_check(L, (n) < (L->top.p - L->ci->func.p), \ | | ------------------ | | | | 126| 61|#define api_check(l,e,msg) luai_apicheck(l,(e) && msg) | | | | ------------------ | | | | | | 123| 61|#define luai_apicheck(l,e) ((void)l, lua_assert(e)) | | | | | | ------------------ | | | | | | | | 114| 61|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 34| 61| "not enough elements in the stack") ------------------ 532| 61| luaD_poscall(L, ci, n); 533| 61| return n; 534| 61|} ldo.c:prepCallInfo: 503| 19.8k| int mask, StkId top) { 504| 19.8k| CallInfo *ci = L->ci = next_ci(L); /* new frame */ ------------------ | | 499| 19.8k|#define next_ci(L) (L->ci->next ? L->ci->next : luaE_extendCI(L)) | | ------------------ | | | Branch (499:22): [True: 18.4k, False: 1.39k] | | ------------------ ------------------ 505| 19.8k| ci->func.p = func; 506| 19.8k| ci->nresults = nret; 507| 19.8k| ci->callstatus = mask; 508| 19.8k| ci->top.p = top; 509| 19.8k| return ci; 510| 19.8k|} ldo.c:ccall: 628| 101|l_sinline void ccall (lua_State *L, StkId func, int nResults, l_uint32 inc) { 629| 101| CallInfo *ci; 630| 101| L->nCcalls += inc; 631| 101| if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) { ------------------ | | 688| 101|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 101|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 101] | | | | ------------------ | | ------------------ ------------------ 632| 0| checkstackp(L, 0, func); /* free any use of EXTRA_STACK */ ------------------ | | 42| 0| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 0| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 0| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 0| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 0|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 43| 0| ptrdiff_t t__ = savestack(L, p), /* save 'p' */ \ | | 44| 0| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 633| 0| luaE_checkcstack(L); 634| 0| } 635| 101| if ((ci = luaD_precall(L, func, nResults)) != NULL) { /* Lua function? */ ------------------ | Branch (635:7): [True: 40, False: 61] ------------------ 636| 40| ci->callstatus = CIST_FRESH; /* mark that it is a "fresh" execute */ ------------------ | | 212| 40|#define CIST_FRESH (1<<2) /* call is on a fresh "luaV_execute" frame */ ------------------ 637| 40| luaV_execute(L, ci); /* call it */ 638| 40| } 639| 101| L->nCcalls -= inc; 640| 101|} ldo.c:closepaux: 914| 515|static void closepaux (lua_State *L, void *ud) { 915| 515| struct CloseP *pcl = cast(struct CloseP *, ud); ------------------ | | 136| 515|#define cast(t, exp) ((t)(exp)) ------------------ 916| 515| luaF_close(L, pcl->level, pcl->status, 0); 917| 515|} ldo.c:f_parser: 988| 258|static void f_parser (lua_State *L, void *ud) { 989| 258| LClosure *cl; 990| 258| struct SParser *p = cast(struct SParser *, ud); ------------------ | | 136| 258|#define cast(t, exp) ((t)(exp)) ------------------ 991| 258| int c = zgetc(p->z); /* read first character */ ------------------ | | 20| 258|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | ------------------ | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | | Branch (20:20): [True: 0, False: 258] | | ------------------ ------------------ 992| 258| if (c == LUA_SIGNATURE[0]) { ------------------ | | 33| 258|#define LUA_SIGNATURE "\x1bLua" ------------------ | Branch (992:7): [True: 0, False: 258] ------------------ 993| 0| checkmode(L, p->mode, "binary"); 994| 0| cl = luaU_undump(L, p->z, p->name); 995| 0| } 996| 258| else { 997| 258| checkmode(L, p->mode, "text"); 998| 258| cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c); 999| 258| } 1000| 258| lua_assert(cl->nupvalues == cl->p->sizeupvalues); ------------------ | | 114| 258|#define lua_assert(c) ((void)0) ------------------ 1001| 258| luaF_initupvals(L, cl); 1002| 258|} ldo.c:checkmode: 979| 258|static void checkmode (lua_State *L, const char *mode, const char *x) { 980| 258| if (mode && strchr(mode, x[0]) == NULL) { ------------------ | Branch (980:7): [True: 258, False: 0] | Branch (980:15): [True: 0, False: 258] ------------------ 981| 0| luaO_pushfstring(L, 982| 0| "attempt to load a %s chunk (mode is '%s')", x, mode); 983| 0| luaD_throw(L, LUA_ERRSYNTAX); ------------------ | | 52| 0|#define LUA_ERRSYNTAX 3 ------------------ 984| 0| } 985| 258|} luaF_newLclosure: 35| 9.49k|LClosure *luaF_newLclosure (lua_State *L, int nupvals) { 36| 9.49k| GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals)); ------------------ | | 590| 9.49k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 9.49k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ GCObject *o = luaC_newobj(L, LUA_VLCL, sizeLclosure(nupvals)); ------------------ | | 17| 9.49k|#define sizeLclosure(n) (cast_int(offsetof(LClosure, upvals)) + \ | | ------------------ | | | | 141| 9.49k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 9.49k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 18| 9.49k| cast_int(sizeof(TValue *)) * (n)) | | ------------------ | | | | 141| 9.49k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 9.49k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 37| 9.49k| LClosure *c = gco2lcl(o); ------------------ | | 376| 9.49k|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 115| 9.49k|#define check_exp(c,e) (e) | | ------------------ ------------------ 38| 9.49k| c->p = NULL; 39| 9.49k| c->nupvalues = cast_byte(nupvals); ------------------ | | 143| 9.49k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 9.49k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 40| 28.2k| while (nupvals--) c->upvals[nupvals] = NULL; ------------------ | Branch (40:10): [True: 18.7k, False: 9.49k] ------------------ 41| 9.49k| return c; 42| 9.49k|} luaF_initupvals: 48| 40|void luaF_initupvals (lua_State *L, LClosure *cl) { 49| 40| int i; 50| 80| for (i = 0; i < cl->nupvalues; i++) { ------------------ | Branch (50:15): [True: 40, False: 40] ------------------ 51| 40| GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal)); ------------------ | | 586| 40|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 40|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 52| 40| UpVal *uv = gco2upv(o); ------------------ | | 383| 40|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 115| 40|#define check_exp(c,e) (e) | | ------------------ ------------------ 53| 40| uv->v.p = &uv->u.value; /* make it closed */ 54| 40| setnilvalue(uv->v.p); ------------------ | | 200| 40|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 40|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 55| 40| cl->upvals[i] = uv; 56| 40| luaC_objbarrier(L, cl, uv); ------------------ | | 175| 40|#define luaC_objbarrier(L,p,o) ( \ | | 176| 40| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 40|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 40|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 80|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 40] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 40| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 40|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 40|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 57| 40| } 58| 40|} luaF_findupval: 87| 9.22k|UpVal *luaF_findupval (lua_State *L, StkId level) { 88| 9.22k| UpVal **pp = &L->openupval; 89| 9.22k| UpVal *p; 90| 9.22k| lua_assert(isintwups(L) || L->openupval == NULL); ------------------ | | 114| 9.22k|#define lua_assert(c) ((void)0) ------------------ 91| 9.26k| while ((p = *pp) != NULL && uplevel(p) >= level) { /* search for it */ ------------------ | | 35| 64|#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p)) | | ------------------ | | | | 115| 64|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (91:10): [True: 64, False: 9.20k] | Branch (91:31): [True: 60, False: 4] ------------------ 92| 60| lua_assert(!isdead(G(L), p)); ------------------ | | 114| 60|#define lua_assert(c) ((void)0) ------------------ 93| 60| if (uplevel(p) == level) /* corresponding upvalue? */ ------------------ | | 35| 60|#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p)) | | ------------------ | | | | 115| 60|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (93:9): [True: 24, False: 36] ------------------ 94| 24| return p; /* return it */ 95| 36| pp = &p->u.open.next; 96| 36| } 97| | /* not found: create a new upvalue after 'pp' */ 98| 9.20k| return newupval(L, level, pp); 99| 9.22k|} luaF_newtbcupval: 168| 14.3k|void luaF_newtbcupval (lua_State *L, StkId level) { 169| 14.3k| lua_assert(level > L->tbclist.p); ------------------ | | 114| 14.3k|#define lua_assert(c) ((void)0) ------------------ 170| 14.3k| if (l_isfalse(s2v(level))) ------------------ | | 247| 14.3k|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 14.3k|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 28.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 14.3k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 4, False: 14.3k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 193| 14.3k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 14.3k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 14.3k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 14.3k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 14.3k, False: 12] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 171| 14.3k| return; /* false doesn't need to be closed */ 172| 12| checkclosemth(L, level); /* value must have a close method */ 173| 12| while (cast_uint(level - L->tbclist.p) > MAXDELTA) { ------------------ | | 142| 12|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ while (cast_uint(level - L->tbclist.p) > MAXDELTA) { ------------------ | | 162| 12| ((256ul << ((sizeof(L->stack.p->tbclist.delta) - 1) * 8)) - 1) ------------------ | Branch (173:10): [True: 0, False: 12] ------------------ 174| 0| L->tbclist.p += MAXDELTA; /* create a dummy node at maximum delta */ ------------------ | | 162| 0| ((256ul << ((sizeof(L->stack.p->tbclist.delta) - 1) * 8)) - 1) ------------------ 175| 0| L->tbclist.p->tbclist.delta = 0; 176| 0| } 177| 12| level->tbclist.delta = cast(unsigned short, level - L->tbclist.p); ------------------ | | 136| 12|#define cast(t, exp) ((t)(exp)) ------------------ 178| 12| L->tbclist.p = level; 179| 12|} luaF_unlinkupval: 182| 9.20k|void luaF_unlinkupval (UpVal *uv) { 183| 9.20k| lua_assert(upisopen(uv)); ------------------ | | 114| 9.20k|#define lua_assert(c) ((void)0) ------------------ 184| 9.20k| *uv->u.open.previous = uv->u.open.next; 185| 9.20k| if (uv->u.open.next) ------------------ | Branch (185:7): [True: 6, False: 9.19k] ------------------ 186| 6| uv->u.open.next->u.open.previous = uv->u.open.previous; 187| 9.20k|} luaF_closeupval: 193| 9.73k|void luaF_closeupval (lua_State *L, StkId level) { 194| 9.73k| UpVal *uv; 195| 9.73k| StkId upl; /* stack index pointed by 'uv' */ 196| 18.9k| while ((uv = L->openupval) != NULL && (upl = uplevel(uv)) >= level) { ------------------ | | 35| 9.20k|#define uplevel(up) check_exp(upisopen(up), cast(StkId, (up)->v.p)) | | ------------------ | | | | 115| 9.20k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (196:10): [True: 9.20k, False: 9.73k] | Branch (196:41): [True: 9.20k, False: 0] ------------------ 197| 9.20k| TValue *slot = &uv->u.value; /* new position for value */ 198| 9.20k| lua_assert(uplevel(uv) < L->top.p); ------------------ | | 114| 9.20k|#define lua_assert(c) ((void)0) ------------------ 199| 9.20k| luaF_unlinkupval(uv); /* remove upvalue from 'openupval' list */ 200| 9.20k| setobj(L, slot, uv->v.p); /* move value to upvalue slot */ ------------------ | | 119| 9.20k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 9.20k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 9.20k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 9.20k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 9.20k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 9.20k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 9.20k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 9.20k|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 201| 9.20k| uv->v.p = slot; /* now current value lives here */ 202| 9.20k| if (!iswhite(uv)) { /* neither white nor dead? */ ------------------ | | 87| 9.20k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 9.20k|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (202:9): [True: 6, False: 9.19k] ------------------ 203| 6| nw2black(uv); /* closed upvalues cannot be gray */ ------------------ | | 100| 6| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 115| 6|#define check_exp(c,e) (e) | | ------------------ ------------------ 204| 6| luaC_barrier(L, uv, slot); ------------------ | | 179| 6|#define luaC_barrier(L,p,v) ( \ | | 180| 6| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 6|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 6|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 6|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 0, False: 6] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 0|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 0| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 177| 0| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 6|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 6|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 205| 6| } 206| 9.20k| } 207| 9.73k|} luaF_close: 227| 9.73k|StkId luaF_close (lua_State *L, StkId level, int status, int yy) { 228| 9.73k| ptrdiff_t levelrel = savestack(L, level); ------------------ | | 36| 9.73k|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 9.73k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 9.73k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 9.73k|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 9.73k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 229| 9.73k| luaF_closeupval(L, level); /* first, close the upvalues */ 230| 9.74k| while (L->tbclist.p >= level) { /* traverse tbc's down to that level */ ------------------ | Branch (230:10): [True: 11, False: 9.73k] ------------------ 231| 11| StkId tbc = L->tbclist.p; /* get variable index */ 232| 11| poptbclist(L); /* remove it from list */ 233| 11| prepcallclosemth(L, tbc, status, yy); /* close variable */ 234| 11| level = restorestack(L, levelrel); ------------------ | | 37| 11|#define restorestack(L,n) cast(StkId, cast_charp(L->stack.p) + (n)) | | ------------------ | | | | 136| 11|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 235| 11| } 236| 9.73k| return level; 237| 9.73k|} luaF_newproto: 240| 4.49k|Proto *luaF_newproto (lua_State *L) { 241| 4.49k| GCObject *o = luaC_newobj(L, LUA_VPROTO, sizeof(Proto)); ------------------ | | 509| 4.49k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 4.49k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 242| 4.49k| Proto *f = gco2p(o); ------------------ | | 381| 4.49k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 115| 4.49k|#define check_exp(c,e) (e) | | ------------------ ------------------ 243| 4.49k| f->k = NULL; 244| 4.49k| f->sizek = 0; 245| 4.49k| f->p = NULL; 246| 4.49k| f->sizep = 0; 247| 4.49k| f->code = NULL; 248| 4.49k| f->sizecode = 0; 249| 4.49k| f->lineinfo = NULL; 250| 4.49k| f->sizelineinfo = 0; 251| 4.49k| f->abslineinfo = NULL; 252| 4.49k| f->sizeabslineinfo = 0; 253| 4.49k| f->upvalues = NULL; 254| 4.49k| f->sizeupvalues = 0; 255| 4.49k| f->numparams = 0; 256| 4.49k| f->is_vararg = 0; 257| 4.49k| f->maxstacksize = 0; 258| 4.49k| f->locvars = NULL; 259| 4.49k| f->sizelocvars = 0; 260| 4.49k| f->linedefined = 0; 261| 4.49k| f->lastlinedefined = 0; 262| 4.49k| f->source = NULL; 263| 4.49k| return f; 264| 4.49k|} luaF_freeproto: 267| 4.49k|void luaF_freeproto (lua_State *L, Proto *f) { 268| 4.49k| luaM_freearray(L, f->code, f->sizecode); ------------------ | | 57| 4.49k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 269| 4.49k| luaM_freearray(L, f->p, f->sizep); ------------------ | | 57| 4.49k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 270| 4.49k| luaM_freearray(L, f->k, f->sizek); ------------------ | | 57| 4.49k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 271| 4.49k| luaM_freearray(L, f->lineinfo, f->sizelineinfo); ------------------ | | 57| 4.49k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 272| 4.49k| luaM_freearray(L, f->abslineinfo, f->sizeabslineinfo); ------------------ | | 57| 4.49k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 273| 4.49k| luaM_freearray(L, f->locvars, f->sizelocvars); ------------------ | | 57| 4.49k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 274| 4.49k| luaM_freearray(L, f->upvalues, f->sizeupvalues); ------------------ | | 57| 4.49k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 275| 4.49k| luaM_free(L, f); ------------------ | | 56| 4.49k|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 276| 4.49k|} luaF_getlocalname: 283| 61|const char *luaF_getlocalname (const Proto *f, int local_number, int pc) { 284| 61| int i; 285| 2.54k| for (i = 0; isizelocvars && f->locvars[i].startpc <= pc; i++) { ------------------ | Branch (285:15): [True: 2.48k, False: 57] | Branch (285:35): [True: 2.48k, False: 2] ------------------ 286| 2.48k| if (pc < f->locvars[i].endpc) { /* is variable active? */ ------------------ | Branch (286:9): [True: 2.28k, False: 194] ------------------ 287| 2.28k| local_number--; 288| 2.28k| if (local_number == 0) ------------------ | Branch (288:11): [True: 2, False: 2.28k] ------------------ 289| 2| return getstr(f->locvars[i].varname); ------------------ | | 403| 2|#define getstr(ts) ((ts)->contents) ------------------ 290| 2.28k| } 291| 2.48k| } 292| 59| return NULL; /* not found */ 293| 61|} lfunc.c:newupval: 65| 9.20k|static UpVal *newupval (lua_State *L, StkId level, UpVal **prev) { 66| 9.20k| GCObject *o = luaC_newobj(L, LUA_VUPVAL, sizeof(UpVal)); ------------------ | | 586| 9.20k|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 9.20k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 67| 9.20k| UpVal *uv = gco2upv(o); ------------------ | | 383| 9.20k|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 115| 9.20k|#define check_exp(c,e) (e) | | ------------------ ------------------ 68| 9.20k| UpVal *next = *prev; 69| 9.20k| uv->v.p = s2v(level); /* current value lives in the stack */ ------------------ | | 172| 9.20k|#define s2v(o) (&(o)->val) ------------------ 70| 9.20k| uv->u.open.next = next; /* link it to list of open upvalues */ 71| 9.20k| uv->u.open.previous = prev; 72| 9.20k| if (next) ------------------ | Branch (72:7): [True: 4, False: 9.20k] ------------------ 73| 4| next->u.open.previous = &uv->u.open.next; 74| 9.20k| *prev = uv; 75| 9.20k| if (!isintwups(L)) { /* thread not in list of threads with upvalues? */ ------------------ | | 22| 9.20k|#define isintwups(L) (L->twups != L) ------------------ | Branch (75:7): [True: 3, False: 9.20k] ------------------ 76| 3| L->twups = G(L)->twups; /* link it to the list */ ------------------ | | 335| 3|#define G(L) (L->l_G) ------------------ 77| 3| G(L)->twups = L; ------------------ | | 335| 3|#define G(L) (L->l_G) ------------------ 78| 3| } 79| 9.20k| return uv; 80| 9.20k|} lfunc.c:checkclosemth: 125| 12|static void checkclosemth (lua_State *L, StkId level) { 126| 12| const TValue *tm = luaT_gettmbyobj(L, s2v(level), TM_CLOSE); ------------------ | | 172| 12|#define s2v(o) (&(o)->val) ------------------ 127| 12| if (ttisnil(tm)) { /* no metamethod? */ ------------------ | | 193| 12|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 12|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 12|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 12|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 1, False: 11] | | | | ------------------ | | ------------------ ------------------ 128| 1| int idx = cast_int(level - L->ci->func.p); /* variable index */ ------------------ | | 141| 1|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 1|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 129| 1| const char *vname = luaG_findlocal(L, L->ci, idx, NULL); 130| 1| if (vname == NULL) vname = "?"; ------------------ | Branch (130:9): [True: 0, False: 1] ------------------ 131| 1| luaG_runerror(L, "variable '%s' got a non-closable value", vname); 132| 1| } 133| 12|} lfunc.c:poptbclist: 213| 11|static void poptbclist (lua_State *L) { 214| 11| StkId tbc = L->tbclist.p; 215| 11| lua_assert(tbc->tbclist.delta > 0); /* first element cannot be dummy */ ------------------ | | 114| 11|#define lua_assert(c) ((void)0) ------------------ 216| 11| tbc -= tbc->tbclist.delta; 217| 11| while (tbc > L->stack.p && tbc->tbclist.delta == 0) ------------------ | Branch (217:10): [True: 0, False: 11] | Branch (217:30): [True: 0, False: 0] ------------------ 218| 0| tbc -= MAXDELTA; /* remove dummy nodes */ ------------------ | | 162| 0| ((256ul << ((sizeof(L->stack.p->tbclist.delta) - 1) * 8)) - 1) ------------------ 219| 11| L->tbclist.p = tbc; 220| 11|} lfunc.c:prepcallclosemth: 143| 11|static void prepcallclosemth (lua_State *L, StkId level, int status, int yy) { 144| 11| TValue *uv = s2v(level); /* value being closed */ ------------------ | | 172| 11|#define s2v(o) (&(o)->val) ------------------ 145| 11| TValue *errobj; 146| 11| if (status == CLOSEKTOP) ------------------ | | 47| 11|#define CLOSEKTOP (-1) ------------------ | Branch (146:7): [True: 11, False: 0] ------------------ 147| 11| errobj = &G(L)->nilvalue; /* error object is nil */ ------------------ | | 335| 11|#define G(L) (L->l_G) ------------------ 148| 0| else { /* 'luaD_seterrorobj' will set top to level + 2 */ 149| 0| errobj = s2v(level + 1); /* error object goes after 'uv' */ ------------------ | | 172| 0|#define s2v(o) (&(o)->val) ------------------ 150| 0| luaD_seterrorobj(L, status, level + 1); /* set error object */ 151| 0| } 152| 11| callclosemethod(L, uv, errobj, yy); 153| 11|} lfunc.c:callclosemethod: 107| 11|static void callclosemethod (lua_State *L, TValue *obj, TValue *err, int yy) { 108| 11| StkId top = L->top.p; 109| 11| const TValue *tm = luaT_gettmbyobj(L, obj, TM_CLOSE); 110| 11| setobj2s(L, top, tm); /* will call metamethod... */ ------------------ | | 131| 11|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 11| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 11| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 11|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 11| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 11| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 11|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 11| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 111| 11| setobj2s(L, top + 1, obj); /* with 'self' as the 1st argument */ ------------------ | | 131| 11|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 11| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 11| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 11|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 11| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 11| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 11|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 11| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 112| 11| setobj2s(L, top + 2, err); /* and error msg. as 2nd argument */ ------------------ | | 131| 11|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 11| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 11| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 11|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 11| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 11| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 11|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 11| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 113| 11| L->top.p = top + 3; /* add function and arguments */ 114| 11| if (yy) ------------------ | Branch (114:7): [True: 0, False: 11] ------------------ 115| 0| luaD_call(L, top, 0); 116| 11| else 117| 11| luaD_callnoyield(L, top, 0); 118| 11|} luaC_barrierback_: 230| 13|void luaC_barrierback_ (lua_State *L, GCObject *o) { 231| 13| global_State *g = G(L); ------------------ | | 335| 13|#define G(L) (L->l_G) ------------------ 232| 13| lua_assert(isblack(o) && !isdead(g, o)); ------------------ | | 114| 13|#define lua_assert(c) ((void)0) ------------------ 233| 13| lua_assert((g->gckind == KGC_GEN) == (isold(o) && getage(o) != G_TOUCHED1)); ------------------ | | 114| 13|#define lua_assert(c) ((void)0) ------------------ 234| 13| if (getage(o) == G_TOUCHED2) /* already in gray list? */ ------------------ | | 116| 13|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 114| 13|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ if (getage(o) == G_TOUCHED2) /* already in gray list? */ ------------------ | | 112| 13|#define G_TOUCHED2 6 /* old object touched in previous cycle */ ------------------ | Branch (234:7): [True: 0, False: 13] ------------------ 235| 13| set2gray(o); /* make it gray to become touched1 */ ------------------ | | 75| 0|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 60| 0|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 0|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 236| 13| else /* link it in 'grayagain' and paint it gray */ 237| 13| linkobjgclist(o, g->grayagain); ------------------ | | 159| 13|#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p)) | | ------------------ | | | | 390| 13|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 13|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 238| 13| if (isold(o)) /* generational mode? */ ------------------ | | 118| 13|#define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 116| 13|#define getage(o) ((o)->marked & AGEBITS) | | | | ------------------ | | | | | | 114| 13|#define AGEBITS 7 /* all age bits (111) */ | | | | ------------------ | | ------------------ | | #define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 107| 13|#define G_SURVIVAL 1 /* created in previous cycle */ | | ------------------ | | | Branch (118:18): [True: 0, False: 13] | | ------------------ ------------------ 239| 0| setage(o, G_TOUCHED1); /* touched in current cycle */ ------------------ | | 117| 0|#define setage(o,a) ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a)) | | ------------------ | | | | 143| 0|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 240| 13|} luaC_fix: 243| 12.6k|void luaC_fix (lua_State *L, GCObject *o) { 244| 12.6k| global_State *g = G(L); ------------------ | | 335| 12.6k|#define G(L) (L->l_G) ------------------ 245| 12.6k| lua_assert(g->allgc == o); /* object must be 1st in 'allgc' list! */ ------------------ | | 114| 12.6k|#define lua_assert(c) ((void)0) ------------------ 246| 12.6k| set2gray(o); /* they will be gray forever */ ------------------ | | 75| 12.6k|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 60| 12.6k|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 12.6k|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 12.6k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 247| 12.6k| setage(o, G_OLD); /* and old forever */ ------------------ | | 117| 12.6k|#define setage(o,a) ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a)) | | ------------------ | | | | 143| 12.6k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 12.6k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 248| 12.6k| g->allgc = o->next; /* remove object from 'allgc' list */ 249| 12.6k| o->next = g->fixedgc; /* link it to 'fixedgc' list */ 250| 12.6k| g->fixedgc = o; 251| 12.6k|} luaC_newobjdt: 258| 414k|GCObject *luaC_newobjdt (lua_State *L, int tt, size_t sz, size_t offset) { 259| 414k| global_State *g = G(L); ------------------ | | 335| 414k|#define G(L) (L->l_G) ------------------ 260| 414k| char *p = cast_charp(luaM_newobject(L, novariant(tt), sz)); ------------------ | | 146| 414k|#define cast_charp(i) cast(char *, (i)) | | ------------------ | | | | 136| 414k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 261| 414k| GCObject *o = cast(GCObject *, p + offset); ------------------ | | 136| 414k|#define cast(t, exp) ((t)(exp)) ------------------ 262| 414k| o->marked = luaC_white(g); ------------------ | | 102| 414k|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 143| 414k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 414k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 263| 414k| o->tt = tt; 264| 414k| o->next = g->allgc; 265| 414k| g->allgc = o; 266| 414k| return o; 267| 414k|} luaC_newobj: 270| 414k|GCObject *luaC_newobj (lua_State *L, int tt, size_t sz) { 271| 414k| return luaC_newobjdt(L, tt, sz, 0); 272| 414k|} luaC_checkfinalizer: 1017| 11|void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt) { 1018| 11| global_State *g = G(L); ------------------ | | 335| 11|#define G(L) (L->l_G) ------------------ 1019| 11| if (tofinalize(o) || /* obj. is already marked... */ ------------------ | | 92| 11|#define tofinalize(x) testbit((x)->marked, FINALIZEDBIT) | | ------------------ | | | | 67| 11|#define testbit(x,b) testbits(x, bitmask(b)) | | | | ------------------ | | | | | | 62| 22|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 11] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1020| 11| gfasttm(g, mt, TM_GC) == NULL || /* or has no finalizer... */ ------------------ | | 65| 11|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | ------------------ | | | Branch (65:26): [True: 0, False: 11] | | ------------------ | | 66| 11| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | ------------------ | | | Branch (66:3): [True: 0, False: 11] | | ------------------ ------------------ | Branch (1020:7): [True: 0, False: 11] ------------------ 1021| 11| (g->gcstp & GCSTPCLS)) /* or closing state? */ ------------------ | | 157| 11|#define GCSTPCLS 4 /* bit true when closing Lua state */ ------------------ | Branch (1021:7): [True: 0, False: 11] ------------------ 1022| 0| return; /* nothing to be done */ 1023| 11| else { /* move 'o' to 'finobj' list */ 1024| 11| GCObject **p; 1025| 11| if (issweepphase(g)) { ------------------ | | 43| 11| (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 34| 11|#define GCSswpallgc 3 | | ------------------ | | (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 37| 11|#define GCSswpend 6 | | ------------------ | | | Branch (43:3): [True: 11, False: 0] | | | Branch (43:34): [True: 0, False: 11] | | ------------------ ------------------ 1026| 0| makewhite(g, o); /* "sweep" object 'o' */ ------------------ | | 72| 0| (x->marked = cast_byte((x->marked & ~maskcolors) | luaC_white(g))) | | ------------------ | | | | 143| 0|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1027| 0| if (g->sweepgc == &o->next) /* should not remove 'sweepgc' object */ ------------------ | Branch (1027:11): [True: 0, False: 0] ------------------ 1028| 0| g->sweepgc = sweeptolive(L, g->sweepgc); /* change 'sweepgc' */ 1029| 0| } 1030| 11| else 1031| 11| correctpointers(g, o); 1032| | /* search for pointer pointing to 'o' */ 1033| 44| for (p = &g->allgc; *p != o; p = &(*p)->next) { /* empty */ } ------------------ | Branch (1033:25): [True: 33, False: 11] ------------------ 1034| 11| *p = o->next; /* remove 'o' from 'allgc' list */ 1035| 11| o->next = g->finobj; /* link it in 'finobj' list */ 1036| 11| g->finobj = o; 1037| 11| l_setbit(o->marked, FINALIZEDBIT); /* mark it as such */ ------------------ | | 65| 11|#define l_setbit(x,b) setbits(x, bitmask(b)) | | ------------------ | | | | 61| 11|#define setbits(x,m) ((x) |= (m)) | | ------------------ ------------------ 1038| 11| } 1039| 11|} luaC_changemode: 1358| 258|void luaC_changemode (lua_State *L, int newmode) { 1359| 258| global_State *g = G(L); ------------------ | | 335| 258|#define G(L) (L->l_G) ------------------ 1360| 258| if (newmode != g->gckind) { ------------------ | Branch (1360:7): [True: 0, False: 258] ------------------ 1361| 0| if (newmode == KGC_GEN) /* entering generational mode? */ ------------------ | | 152| 0|#define KGC_GEN 1 /* generational gc */ ------------------ | Branch (1361:9): [True: 0, False: 0] ------------------ 1362| 0| entergen(L, g); 1363| 0| else 1364| 0| enterinc(g); /* entering incremental mode */ 1365| 0| } 1366| 258| g->lastatomic = 0; 1367| 258|} luaC_freeallobjects: 1509| 258|void luaC_freeallobjects (lua_State *L) { 1510| 258| global_State *g = G(L); ------------------ | | 335| 258|#define G(L) (L->l_G) ------------------ 1511| 258| g->gcstp = GCSTPCLS; /* no extra finalizers after here */ ------------------ | | 157| 258|#define GCSTPCLS 4 /* bit true when closing Lua state */ ------------------ 1512| 258| luaC_changemode(L, KGC_INC); ------------------ | | 151| 258|#define KGC_INC 0 /* incremental gc */ ------------------ 1513| 258| separatetobefnz(g, 1); /* separate all objects with finalizers */ 1514| 258| lua_assert(g->finobj == NULL); ------------------ | | 114| 258|#define lua_assert(c) ((void)0) ------------------ 1515| 258| callallpendingfinalizers(L); 1516| 258| deletelist(L, g->allgc, obj2gco(g->mainthread)); ------------------ | | 390| 258|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 258|#define check_exp(c,e) (e) | | ------------------ ------------------ 1517| 258| lua_assert(g->finobj == NULL); /* no new finalizers */ ------------------ | | 114| 258|#define lua_assert(c) ((void)0) ------------------ 1518| 258| deletelist(L, g->fixedgc, NULL); /* collect fixed objects */ 1519| 258| lua_assert(g->strt.nuse == 0); ------------------ | | 114| 258|#define lua_assert(c) ((void)0) ------------------ 1520| 258|} luaC_step: 1688| 1.01k|void luaC_step (lua_State *L) { 1689| 1.01k| global_State *g = G(L); ------------------ | | 335| 1.01k|#define G(L) (L->l_G) ------------------ 1690| 1.01k| if (!gcrunning(g)) /* not running? */ ------------------ | | 158| 1.01k|#define gcrunning(g) ((g)->gcstp == 0) ------------------ | Branch (1690:7): [True: 0, False: 1.01k] ------------------ 1691| 0| luaE_setdebt(g, -2000); 1692| 1.01k| else { 1693| 1.01k| if(isdecGCmodegen(g)) ------------------ | | 149| 1.01k|#define isdecGCmodegen(g) (g->gckind == KGC_GEN || g->lastatomic != 0) | | ------------------ | | | | 152| 2.03k|#define KGC_GEN 1 /* generational gc */ | | ------------------ | | | Branch (149:28): [True: 0, False: 1.01k] | | | Branch (149:52): [True: 0, False: 1.01k] | | ------------------ ------------------ 1694| 0| genstep(L, g); 1695| 1.01k| else 1696| 1.01k| incstep(L, g); 1697| 1.01k| } 1698| 1.01k|} lgc.c:linkgclist_: 148| 13.4k|static void linkgclist_ (GCObject *o, GCObject **pnext, GCObject **list) { 149| 13.4k| lua_assert(!isgray(o)); /* cannot be in a gray list */ ------------------ | | 114| 13.4k|#define lua_assert(c) ((void)0) ------------------ 150| 13.4k| *pnext = *list; 151| 13.4k| *list = o; 152| 13.4k| set2gray(o); /* now it is */ ------------------ | | 75| 13.4k|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 60| 13.4k|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 13.4k|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 13.4k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 153| 13.4k|} lgc.c:getgclist: 125| 25.7k|static GCObject **getgclist (GCObject *o) { 126| 25.7k| switch (o->tt) { 127| 6.03k| case LUA_VTABLE: return &gco2t(o)->gclist; ------------------ | | 680| 6.03k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 6.03k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTABLE: return &gco2t(o)->gclist; ------------------ | | 380| 6.03k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 6.03k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (127:5): [True: 6.03k, False: 19.7k] ------------------ 128| 2.07k| case LUA_VLCL: return &gco2lcl(o)->gclist; ------------------ | | 590| 2.07k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 2.07k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: return &gco2lcl(o)->gclist; ------------------ | | 376| 2.07k|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 115| 2.07k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (128:5): [True: 2.07k, False: 23.7k] ------------------ 129| 0| case LUA_VCCL: return &gco2ccl(o)->gclist; ------------------ | | 592| 0|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VCCL: return &gco2ccl(o)->gclist; ------------------ | | 377| 0|#define gco2ccl(o) check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (129:5): [True: 0, False: 25.7k] ------------------ 130| 3.01k| case LUA_VTHREAD: return &gco2th(o)->gclist; ------------------ | | 262| 3.01k|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 3.01k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: return &gco2th(o)->gclist; ------------------ | | 382| 3.01k|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 115| 3.01k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (130:5): [True: 3.01k, False: 22.7k] ------------------ 131| 14.6k| case LUA_VPROTO: return &gco2p(o)->gclist; ------------------ | | 509| 14.6k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 14.6k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VPROTO: return &gco2p(o)->gclist; ------------------ | | 381| 14.6k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 115| 14.6k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (131:5): [True: 14.6k, False: 11.1k] ------------------ 132| 0| case LUA_VUSERDATA: { ------------------ | | 431| 0|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (132:5): [True: 0, False: 25.7k] ------------------ 133| 0| Udata *u = gco2u(o); ------------------ | | 375| 0|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 134| 0| lua_assert(u->nuvalue > 0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 135| 0| return &u->gclist; 136| 0| } 137| 0| default: lua_assert(0); return 0; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (137:5): [True: 0, False: 25.7k] ------------------ 138| 25.7k| } 139| 25.7k|} lgc.c:reallymarkobject: 297| 49.9k|static void reallymarkobject (global_State *g, GCObject *o) { 298| 49.9k| switch (o->tt) { 299| 33.2k| case LUA_VSHRSTR: ------------------ | | 360| 33.2k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 33.2k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (299:5): [True: 33.2k, False: 16.6k] ------------------ 300| 37.5k| case LUA_VLNGSTR: { ------------------ | | 361| 37.5k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 37.5k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (300:5): [True: 4.23k, False: 45.7k] ------------------ 301| 37.5k| set2black(o); /* nothing to visit */ ------------------ | | 80| 37.5k| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 143| 37.5k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 37.5k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 302| 37.5k| break; 303| 33.2k| } 304| 66| case LUA_VUPVAL: { ------------------ | | 586| 66|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 66|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (304:5): [True: 66, False: 49.9k] ------------------ 305| 66| UpVal *uv = gco2upv(o); ------------------ | | 383| 66|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 115| 66|#define check_exp(c,e) (e) | | ------------------ ------------------ 306| 66| if (upisopen(uv)) ------------------ | | 32| 66|#define upisopen(up) ((up)->v.p != &(up)->u.value) | | ------------------ | | | Branch (32:22): [True: 20, False: 46] | | ------------------ ------------------ 307| 66| set2gray(uv); /* open upvalues are kept gray */ ------------------ | | 75| 20|#define set2gray(x) resetbits(x->marked, maskcolors) | | ------------------ | | | | 60| 20|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 20|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 20|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 308| 46| else 309| 46| set2black(uv); /* closed upvalues are visited here */ ------------------ | | 80| 46| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 143| 46|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 46|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 310| 66| markvalue(g, uv->v.p); /* mark its content */ ------------------ | | 94| 66|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 66| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 66|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 66| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 66| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 66|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 132|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 66|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 66|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 40, False: 26] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 40|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 40|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 40] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 311| 66| break; 312| 33.2k| } 313| 8| case LUA_VUSERDATA: { ------------------ | | 431| 8|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 8|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (313:5): [True: 8, False: 49.9k] ------------------ 314| 8| Udata *u = gco2u(o); ------------------ | | 375| 8|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 115| 8|#define check_exp(c,e) (e) | | ------------------ ------------------ 315| 8| if (u->nuvalue == 0) { /* no user values? */ ------------------ | Branch (315:11): [True: 8, False: 0] ------------------ 316| 8| markobjectN(g, u->metatable); /* mark its metatable */ ------------------ | | 105| 8|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 8] | | ------------------ ------------------ 317| 8| set2black(u); /* nothing else to mark */ ------------------ | | 80| 8| (x->marked = cast_byte((x->marked & ~WHITEBITS) | bitmask(BLACKBIT))) | | ------------------ | | | | 143| 8|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 8|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 318| 8| break; 319| 8| } 320| | /* else... */ 321| 8| } /* FALLTHROUGH */ 322| 4.04k| case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 590| 1.03k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 1.03k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 592| 1.03k|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 1.03k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: case LUA_VCCL: case LUA_VTABLE: ------------------ | | 680| 4.04k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 4.04k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (322:5): [True: 1.03k, False: 48.9k] | Branch (322:20): [True: 0, False: 49.9k] | Branch (322:35): [True: 3.01k, False: 46.9k] ------------------ 323| 12.3k| case LUA_VTHREAD: case LUA_VPROTO: { ------------------ | | 262| 5.04k|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 5.04k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: case LUA_VPROTO: { ------------------ | | 509| 12.3k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 12.3k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (323:5): [True: 1.00k, False: 48.9k] | Branch (323:23): [True: 7.33k, False: 42.6k] ------------------ 324| 12.3k| linkobjgclist(o, g->gray); /* to be visited later */ ------------------ | | 159| 12.3k|#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p)) | | ------------------ | | | | 390| 12.3k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 12.3k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 325| 12.3k| break; 326| 5.04k| } 327| 0| default: lua_assert(0); break; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (327:5): [True: 0, False: 49.9k] ------------------ 328| 49.9k| } 329| 49.9k|} lgc.c:sweeptolive: 849| 1.00k|static GCObject **sweeptolive (lua_State *L, GCObject **p) { 850| 1.00k| GCObject **old = p; 851| 1.02k| do { 852| 1.02k| p = sweeplist(L, p, 1, NULL); 853| 1.02k| } while (p == old); ------------------ | Branch (853:12): [True: 24, False: 1.00k] ------------------ 854| 1.00k| return p; 855| 1.00k|} lgc.c:sweeplist: 823| 7.49k| int *countout) { 824| 7.49k| global_State *g = G(L); ------------------ | | 335| 7.49k|#define G(L) (L->l_G) ------------------ 825| 7.49k| int ow = otherwhite(g); ------------------ | | 94| 7.49k|#define otherwhite(g) ((g)->currentwhite ^ WHITEBITS) | | ------------------ | | | | 84| 7.49k|#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) | | | | ------------------ | | | | | | 64| 7.49k|#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 7.49k|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | | | #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 7.49k|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 826| 7.49k| int i; 827| 7.49k| int white = luaC_white(g); /* current white */ ------------------ | | 102| 7.49k|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 143| 7.49k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 7.49k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 828| 389k| for (i = 0; *p != NULL && i < countin; i++) { ------------------ | Branch (828:15): [True: 386k, False: 3.01k] | Branch (828:29): [True: 382k, False: 4.48k] ------------------ 829| 382k| GCObject *curr = *p; 830| 382k| int marked = curr->marked; 831| 382k| if (isdeadm(ow, marked)) { /* is 'curr' dead? */ ------------------ | | 95| 382k|#define isdeadm(ow,m) ((m) & (ow)) | | ------------------ | | | Branch (95:23): [True: 332k, False: 49.9k] | | ------------------ ------------------ 832| 332k| *p = curr->next; /* remove 'curr' from list */ 833| 332k| freeobj(L, curr); /* erase 'curr' */ 834| 332k| } 835| 49.9k| else { /* change mark to 'white' */ 836| 49.9k| curr->marked = cast_byte((marked & ~maskgcbits) | white); ------------------ | | 143| 49.9k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 49.9k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 837| 49.9k| p = &curr->next; /* go to next element */ 838| 49.9k| } 839| 382k| } 840| 7.49k| if (countout) ------------------ | Branch (840:7): [True: 6.47k, False: 1.02k] ------------------ 841| 6.47k| *countout = i; /* number of elements traversed */ 842| 7.49k| return (*p == NULL) ? NULL : p; ------------------ | Branch (842:10): [True: 3.01k, False: 4.48k] ------------------ 843| 7.49k|} lgc.c:freeobj: 770| 414k|static void freeobj (lua_State *L, GCObject *o) { 771| 414k| switch (o->tt) { 772| 4.49k| case LUA_VPROTO: ------------------ | | 509| 4.49k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 4.49k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (772:5): [True: 4.49k, False: 409k] ------------------ 773| 4.49k| luaF_freeproto(L, gco2p(o)); ------------------ | | 381| 4.49k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 115| 4.49k|#define check_exp(c,e) (e) | | ------------------ ------------------ 774| 4.49k| break; 775| 9.24k| case LUA_VUPVAL: ------------------ | | 586| 9.24k|#define LUA_VUPVAL makevariant(LUA_TUPVAL, 0) | | ------------------ | | | | 42| 9.24k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (775:5): [True: 9.24k, False: 405k] ------------------ 776| 9.24k| freeupval(L, gco2upv(o)); ------------------ | | 383| 9.24k|#define gco2upv(o) check_exp((o)->tt == LUA_VUPVAL, &((cast_u(o))->upv)) | | ------------------ | | | | 115| 9.24k|#define check_exp(c,e) (e) | | ------------------ ------------------ 777| 9.24k| break; 778| 9.49k| case LUA_VLCL: { ------------------ | | 590| 9.49k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 9.49k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (778:5): [True: 9.49k, False: 404k] ------------------ 779| 9.49k| LClosure *cl = gco2lcl(o); ------------------ | | 376| 9.49k|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 115| 9.49k|#define check_exp(c,e) (e) | | ------------------ ------------------ 780| 9.49k| luaM_freemem(L, cl, sizeLclosure(cl->nupvalues)); ------------------ | | 55| 9.49k|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 781| 9.49k| break; 782| 0| } 783| 0| case LUA_VCCL: { ------------------ | | 592| 0|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (783:5): [True: 0, False: 414k] ------------------ 784| 0| CClosure *cl = gco2ccl(o); ------------------ | | 377| 0|#define gco2ccl(o) check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 785| 0| luaM_freemem(L, cl, sizeCclosure(cl->nupvalues)); ------------------ | | 55| 0|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 786| 0| break; 787| 0| } 788| 120k| case LUA_VTABLE: ------------------ | | 680| 120k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 120k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (788:5): [True: 120k, False: 293k] ------------------ 789| 120k| luaH_free(L, gco2t(o)); ------------------ | | 380| 120k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 120k|#define check_exp(c,e) (e) | | ------------------ ------------------ 790| 120k| break; 791| 0| case LUA_VTHREAD: ------------------ | | 262| 0|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (791:5): [True: 0, False: 414k] ------------------ 792| 0| luaE_freethread(L, gco2th(o)); ------------------ | | 382| 0|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 793| 0| break; 794| 11| case LUA_VUSERDATA: { ------------------ | | 431| 11|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 11|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (794:5): [True: 11, False: 414k] ------------------ 795| 11| Udata *u = gco2u(o); ------------------ | | 375| 11|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 115| 11|#define check_exp(c,e) (e) | | ------------------ ------------------ 796| 11| luaM_freemem(L, o, sizeudata(u->nuvalue, u->len)); ------------------ | | 55| 22|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) | | ------------------ | | | Branch (55:51): [True: 11, False: 0] | | ------------------ ------------------ 797| 11| break; 798| 0| } 799| 257k| case LUA_VSHRSTR: { ------------------ | | 360| 257k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 257k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (799:5): [True: 257k, False: 156k] ------------------ 800| 257k| TString *ts = gco2ts(o); ------------------ | | 374| 257k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 115| 257k|#define check_exp(c,e) (e) | | ------------------ ------------------ 801| 257k| luaS_remove(L, ts); /* remove it from hash table */ 802| 257k| luaM_freemem(L, ts, sizelstring(ts->shrlen)); ------------------ | | 55| 257k|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 803| 257k| break; 804| 0| } 805| 13.3k| case LUA_VLNGSTR: { ------------------ | | 361| 13.3k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 13.3k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (805:5): [True: 13.3k, False: 400k] ------------------ 806| 13.3k| TString *ts = gco2ts(o); ------------------ | | 374| 13.3k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 115| 13.3k|#define check_exp(c,e) (e) | | ------------------ ------------------ 807| 13.3k| luaM_freemem(L, ts, sizelstring(ts->u.lnglen)); ------------------ | | 55| 13.3k|#define luaM_freemem(L, b, s) luaM_free_(L, (b), (s)) ------------------ 808| 13.3k| break; 809| 0| } 810| 0| default: lua_assert(0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (810:5): [True: 0, False: 414k] ------------------ 811| 414k| } 812| 414k|} lgc.c:freeupval: 763| 9.24k|static void freeupval (lua_State *L, UpVal *uv) { 764| 9.24k| if (upisopen(uv)) ------------------ | | 32| 9.24k|#define upisopen(up) ((up)->v.p != &(up)->u.value) | | ------------------ | | | Branch (32:22): [True: 0, False: 9.24k] | | ------------------ ------------------ 765| 0| luaF_unlinkupval(uv); 766| 9.24k| luaM_free(L, uv); ------------------ | | 56| 9.24k|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 767| 9.24k|} lgc.c:correctpointers: 1005| 11|static void correctpointers (global_State *g, GCObject *o) { 1006| 11| checkpointer(&g->survival, o); 1007| 11| checkpointer(&g->old1, o); 1008| 11| checkpointer(&g->reallyold, o); 1009| 11| checkpointer(&g->firstold1, o); 1010| 11|} lgc.c:checkpointer: 995| 44|static void checkpointer (GCObject **p, GCObject *o) { 996| 44| if (o == *p) ------------------ | Branch (996:7): [True: 0, False: 44] ------------------ 997| 0| *p = o->next; 998| 44|} lgc.c:atomic: 1523| 1.00k|static lu_mem atomic (lua_State *L) { 1524| 1.00k| global_State *g = G(L); ------------------ | | 335| 1.00k|#define G(L) (L->l_G) ------------------ 1525| 1.00k| lu_mem work = 0; 1526| 1.00k| GCObject *origweak, *origall; 1527| 1.00k| GCObject *grayagain = g->grayagain; /* save original list */ 1528| 1.00k| g->grayagain = NULL; 1529| 1.00k| lua_assert(g->ephemeron == NULL && g->weak == NULL); ------------------ | | 114| 1.00k|#define lua_assert(c) ((void)0) ------------------ 1530| 1.00k| lua_assert(!iswhite(g->mainthread)); ------------------ | | 114| 1.00k|#define lua_assert(c) ((void)0) ------------------ 1531| 1.00k| g->gcstate = GCSatomic; ------------------ | | 33| 1.00k|#define GCSatomic 2 ------------------ 1532| 1.00k| markobject(g, L); /* mark running thread */ ------------------ | | 99| 1.00k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 1.00k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 1.00k|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 1.00k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1533| | /* registry and global metatables may be changed by API */ 1534| 1.00k| markvalue(g, &g->l_registry); ------------------ | | 94| 1.00k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 1.00k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 1.00k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 1.00k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 1.00k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 1.00k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 2.00k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 1.00k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 1.00k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 1.00k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 1.00k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 1.00k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 1.00k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1535| 1.00k| markmt(g); /* mark global metatables */ 1536| 1.00k| work += propagateall(g); /* empties 'gray' list */ 1537| | /* remark occasional upvalues of (maybe) dead threads */ 1538| 1.00k| work += remarkupvals(g); 1539| 1.00k| work += propagateall(g); /* propagate changes */ 1540| 1.00k| g->gray = grayagain; 1541| 1.00k| work += propagateall(g); /* traverse 'grayagain' list */ 1542| 1.00k| convergeephemerons(g); 1543| | /* at this point, all strongly accessible objects are marked. */ 1544| | /* Clear values from weak tables, before checking finalizers */ 1545| 1.00k| clearbyvalues(g, g->weak, NULL); 1546| 1.00k| clearbyvalues(g, g->allweak, NULL); 1547| 1.00k| origweak = g->weak; origall = g->allweak; 1548| 1.00k| separatetobefnz(g, 0); /* separate objects to be finalized */ 1549| 1.00k| work += markbeingfnz(g); /* mark objects that will be finalized */ 1550| 1.00k| work += propagateall(g); /* remark, to propagate 'resurrection' */ 1551| 1.00k| convergeephemerons(g); 1552| | /* at this point, all resurrected objects are marked. */ 1553| | /* remove dead objects from weak tables */ 1554| 1.00k| clearbykeys(g, g->ephemeron); /* clear keys from all ephemeron tables */ 1555| 1.00k| clearbykeys(g, g->allweak); /* clear keys from all 'allweak' tables */ 1556| | /* clear values from resurrected weak tables */ 1557| 1.00k| clearbyvalues(g, g->weak, origweak); 1558| 1.00k| clearbyvalues(g, g->allweak, origall); 1559| 1.00k| luaS_clearcache(g); 1560| 1.00k| g->currentwhite = cast_byte(otherwhite(g)); /* flip current white */ ------------------ | | 143| 1.00k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 1.00k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1561| 1.00k| lua_assert(g->gray == NULL); ------------------ | | 114| 1.00k|#define lua_assert(c) ((void)0) ------------------ 1562| 1.00k| return work; /* estimate of slots marked by 'atomic' */ 1563| 1.00k|} lgc.c:markmt: 335| 2.00k|static void markmt (global_State *g) { 336| 2.00k| int i; 337| 20.0k| for (i=0; i < LUA_NUMTAGS; i++) ------------------ | | 426| 20.0k|#define LUA_NUMTAGS LUA_NUMTYPES | | ------------------ | | | | 75| 20.0k|#define LUA_NUMTYPES 9 | | ------------------ ------------------ | Branch (337:13): [True: 18.0k, False: 2.00k] ------------------ 338| 18.0k| markobjectN(g, g->mt[i]); ------------------ | | 105| 18.0k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 18.0k] | | ------------------ ------------------ 339| 2.00k|} lgc.c:propagateall: 674| 4.01k|static lu_mem propagateall (global_State *g) { 675| 4.01k| lu_mem tot = 0; 676| 5.03k| while (g->gray) ------------------ | Branch (676:10): [True: 1.02k, False: 4.01k] ------------------ 677| 1.02k| tot += propagatemark(g); 678| 4.01k| return tot; 679| 4.01k|} lgc.c:propagatemark: 658| 13.3k|static lu_mem propagatemark (global_State *g) { 659| 13.3k| GCObject *o = g->gray; 660| 13.3k| nw2black(o); ------------------ | | 100| 13.3k| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 115| 13.3k|#define check_exp(c,e) (e) | | ------------------ ------------------ 661| 13.3k| g->gray = *getgclist(o); /* remove from 'gray' list */ 662| 13.3k| switch (o->tt) { 663| 3.01k| case LUA_VTABLE: return traversetable(g, gco2t(o)); ------------------ | | 680| 3.01k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 3.01k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTABLE: return traversetable(g, gco2t(o)); ------------------ | | 380| 3.01k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 3.01k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (663:5): [True: 3.01k, False: 10.3k] ------------------ 664| 0| case LUA_VUSERDATA: return traverseudata(g, gco2u(o)); ------------------ | | 431| 0|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VUSERDATA: return traverseudata(g, gco2u(o)); ------------------ | | 375| 0|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (664:5): [True: 0, False: 13.3k] ------------------ 665| 1.03k| case LUA_VLCL: return traverseLclosure(g, gco2lcl(o)); ------------------ | | 590| 1.03k|#define LUA_VLCL makevariant(LUA_TFUNCTION, 0) /* Lua closure */ | | ------------------ | | | | 42| 1.03k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCL: return traverseLclosure(g, gco2lcl(o)); ------------------ | | 376| 1.03k|#define gco2lcl(o) check_exp((o)->tt == LUA_VLCL, &((cast_u(o))->cl.l)) | | ------------------ | | | | 115| 1.03k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (665:5): [True: 1.03k, False: 12.3k] ------------------ 666| 0| case LUA_VCCL: return traverseCclosure(g, gco2ccl(o)); ------------------ | | 592| 0|#define LUA_VCCL makevariant(LUA_TFUNCTION, 2) /* C closure */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VCCL: return traverseCclosure(g, gco2ccl(o)); ------------------ | | 377| 0|#define gco2ccl(o) check_exp((o)->tt == LUA_VCCL, &((cast_u(o))->cl.c)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (666:5): [True: 0, False: 13.3k] ------------------ 667| 7.33k| case LUA_VPROTO: return traverseproto(g, gco2p(o)); ------------------ | | 509| 7.33k|#define LUA_VPROTO makevariant(LUA_TPROTO, 0) | | ------------------ | | | | 42| 7.33k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VPROTO: return traverseproto(g, gco2p(o)); ------------------ | | 381| 7.33k|#define gco2p(o) check_exp((o)->tt == LUA_VPROTO, &((cast_u(o))->p)) | | ------------------ | | | | 115| 7.33k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (667:5): [True: 7.33k, False: 6.05k] ------------------ 668| 2.00k| case LUA_VTHREAD: return traversethread(g, gco2th(o)); ------------------ | | 262| 2.00k|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 2.00k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VTHREAD: return traversethread(g, gco2th(o)); ------------------ | | 382| 2.00k|#define gco2th(o) check_exp((o)->tt == LUA_VTHREAD, &((cast_u(o))->th)) | | ------------------ | | | | 115| 2.00k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (668:5): [True: 2.00k, False: 11.3k] ------------------ 669| 0| default: lua_assert(0); return 0; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (669:5): [True: 0, False: 13.3k] ------------------ 670| 13.3k| } 671| 13.3k|} lgc.c:traversetable: 542| 3.01k|static lu_mem traversetable (global_State *g, Table *h) { 543| 3.01k| const char *weakkey, *weakvalue; 544| 3.01k| const TValue *mode = gfasttm(g, h->metatable, TM_MODE); ------------------ | | 65| 3.01k|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | ------------------ | | | Branch (65:26): [True: 3.01k, False: 0] | | ------------------ | | 66| 3.01k| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | ------------------ | | | Branch (66:3): [True: 0, False: 0] | | ------------------ ------------------ 545| 3.01k| markobjectN(g, h->metatable); ------------------ | | 105| 3.01k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 0, False: 3.01k] | | ------------------ ------------------ 546| 3.01k| if (mode && ttisstring(mode) && /* is there a weak mode? */ ------------------ | | 363| 0|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 3.01k|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (546:7): [True: 0, False: 3.01k] ------------------ 547| 3.01k| (cast_void(weakkey = strchr(svalue(mode), 'k')), ------------------ | | 138| 0|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (547:7): [True: 0, False: 0] ------------------ 548| 0| cast_void(weakvalue = strchr(svalue(mode), 'v')), ------------------ | | 138| 0|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 549| 0| (weakkey || weakvalue))) { /* is really weak? */ ------------------ | Branch (549:9): [True: 0, False: 0] | Branch (549:20): [True: 0, False: 0] ------------------ 550| 0| if (!weakkey) /* strong keys? */ ------------------ | Branch (550:9): [True: 0, False: 0] ------------------ 551| 0| traverseweakvalue(g, h); 552| 0| else if (!weakvalue) /* strong values? */ ------------------ | Branch (552:14): [True: 0, False: 0] ------------------ 553| 0| traverseephemeron(g, h, 0); 554| 0| else /* all weak */ 555| 0| linkgclist(h, g->allweak); /* nothing to traverse now */ ------------------ | | 146| 0|#define linkgclist(o,p) linkgclist_(obj2gco(o), &(o)->gclist, &(p)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 556| 0| } 557| 3.01k| else /* not weak */ 558| 3.01k| traversestrongtable(g, h); 559| 3.01k| return 1 + h->alimit + 2 * allocsizenode(h); ------------------ | | 31| 3.01k|#define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 27| 3.01k|#define isdummy(t) ((t)->lastfree == NULL) | | | | ------------------ | | | | | Branch (27:21): [True: 2.01k, False: 1.00k] | | | | ------------------ | | ------------------ | | #define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 793| 1.00k|#define sizenode(t) (twoto((t)->lsizenode)) | | | | ------------------ | | | | | | 792| 1.00k|#define twoto(x) (1<<(x)) | | | | ------------------ | | ------------------ ------------------ 560| 3.01k|} lgc.c:clearkey: 171| 234k|static void clearkey (Node *n) { 172| 234k| lua_assert(isempty(gval(n))); ------------------ | | 114| 234k|#define lua_assert(c) ((void)0) ------------------ 173| 234k| if (keyiscollectable(n)) ------------------ | | 766| 234k|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 755| 234k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 298| 234k|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ | | | Branch (766:29): [True: 0, False: 234k] | | ------------------ ------------------ 174| 0| setdeadkey(n); /* unused key; remove it */ ------------------ | | 778| 0|#define setdeadkey(node) (keytt(node) = LUA_TDEADKEY) | | ------------------ | | | | 755| 0|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define setdeadkey(node) (keytt(node) = LUA_TDEADKEY) | | ------------------ | | | | 24| 0|#define LUA_TDEADKEY (LUA_NUMTYPES+2) /* removed keys in tables */ | | | | ------------------ | | | | | | 75| 0|#define LUA_NUMTYPES 9 | | | | ------------------ | | ------------------ ------------------ 175| 234k|} lgc.c:genlink: 430| 3.01k|static void genlink (global_State *g, GCObject *o) { 431| 3.01k| lua_assert(isblack(o)); ------------------ | | 114| 3.01k|#define lua_assert(c) ((void)0) ------------------ 432| 3.01k| if (getage(o) == G_TOUCHED1) { /* touched in this cycle? */ ------------------ | | 116| 3.01k|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 114| 3.01k|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ if (getage(o) == G_TOUCHED1) { /* touched in this cycle? */ ------------------ | | 111| 3.01k|#define G_TOUCHED1 5 /* old object touched this cycle */ ------------------ | Branch (432:7): [True: 0, False: 3.01k] ------------------ 433| 0| linkobjgclist(o, g->grayagain); /* link it back in 'grayagain' */ ------------------ | | 159| 0|#define linkobjgclist(o,p) linkgclist_(obj2gco(o), getgclist(o), &(p)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 434| 0| } /* everything else do not need to be linked back */ 435| 3.01k| else if (getage(o) == G_TOUCHED2) ------------------ | | 116| 3.01k|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 114| 3.01k|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ else if (getage(o) == G_TOUCHED2) ------------------ | | 112| 3.01k|#define G_TOUCHED2 6 /* old object touched in previous cycle */ ------------------ | Branch (435:12): [True: 0, False: 3.01k] ------------------ 436| 0| changeage(o, G_TOUCHED2, G_OLD); /* advance age */ ------------------ | | 121| 0| check_exp(getage(o) == (f), (o)->marked ^= ((f)^(t))) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 437| 3.01k|} lgc.c:traversestrongtable: 523| 3.01k|static void traversestrongtable (global_State *g, Table *h) { 524| 3.01k| Node *n, *limit = gnodelast(h); ------------------ | | 122| 3.01k|#define gnodelast(h) gnode(h, cast_sizet(sizenode(h))) | | ------------------ | | | | 13| 3.01k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 525| 3.01k| unsigned int i; 526| 3.01k| unsigned int asize = luaH_realasize(h); 527| 1.96M| for (i = 0; i < asize; i++) /* traverse array part */ ------------------ | Branch (527:15): [True: 1.96M, False: 3.01k] ------------------ 528| 1.96M| markvalue(g, &h->array[i]); ------------------ | | 94| 1.96M|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 1.96M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 1.96M|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 1.96M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 1.96M| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 1.96M|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 3.93M|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 1.96M|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 1.96M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 2.00k, False: 1.96M] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 2.00k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 2.00k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 1.00k, False: 1.00k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 1.00k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 1.00k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 529| 700k| for (n = gnode(h, 0); n < limit; n++) { /* traverse hash part */ ------------------ | | 13| 3.01k|#define gnode(t,i) (&(t)->node[i]) ------------------ | Branch (529:25): [True: 697k, False: 3.01k] ------------------ 530| 697k| if (isempty(gval(n))) /* entry is empty? */ ------------------ | | 217| 697k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 697k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 697k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 697k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 697k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 234k, False: 462k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 531| 234k| clearkey(n); /* clear its key */ 532| 462k| else { 533| 462k| lua_assert(!keyisnil(n)); ------------------ | | 114| 462k|#define lua_assert(c) ((void)0) ------------------ 534| 462k| markkey(g, n); ------------------ | | 97| 462k|#define markkey(g, n) { if keyiswhite(n) reallymarkobject(g,gckey(n)); } | | ------------------ | | | | 85| 462k|#define keyiswhite(n) (keyiscollectable(n) && iswhite(gckey(n))) | | | | ------------------ | | | | | | 766| 925k|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 755| 462k|#define keytt(node) ((node)->u.key_tt) | | | | | | ------------------ | | | | | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 462k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (766:29): [True: 40.0k, False: 422k] | | | | | | ------------------ | | | | ------------------ | | | | #define keyiswhite(n) (keyiscollectable(n) && iswhite(gckey(n))) | | | | ------------------ | | | | | | 87| 40.0k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 40.0k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 34.7k, False: 5.24k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markkey(g, n) { if keyiswhite(n) reallymarkobject(g,gckey(n)); } | | ------------------ | | | | 768| 34.7k|#define gckey(n) (keyval(n).gc) | | | | ------------------ | | | | | | 756| 34.7k|#define keyval(node) ((node)->u.key_val) | | | | ------------------ | | ------------------ ------------------ 535| 462k| markvalue(g, gval(n)); ------------------ | | 94| 462k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 462k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 462k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 462k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 462k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 462k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 925k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 462k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 462k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 7.31k, False: 455k] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 7.31k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 7.31k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 87, False: 7.23k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 87|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 87|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 536| 462k| } 537| 697k| } 538| 3.01k| genlink(g, obj2gco(h)); ------------------ | | 390| 3.01k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 3.01k|#define check_exp(c,e) (e) | | ------------------ ------------------ 539| 3.01k|} lgc.c:traverseLclosure: 604| 1.03k|static int traverseLclosure (global_State *g, LClosure *cl) { 605| 1.03k| int i; 606| 1.03k| markobjectN(g, cl->p); /* mark its prototype */ ------------------ | | 105| 1.03k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 1.03k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 1.03k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 1.03k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 1.02k, False: 6] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 1.02k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 1.02k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 1.03k, False: 0] | | ------------------ ------------------ 607| 2.09k| for (i = 0; i < cl->nupvalues; i++) { /* visit its upvalues */ ------------------ | Branch (607:15): [True: 1.06k, False: 1.03k] ------------------ 608| 1.06k| UpVal *uv = cl->upvals[i]; 609| 1.06k| markobjectN(g, uv); /* mark upvalue */ ------------------ | | 105| 1.06k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 97|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 97|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 97|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 60, False: 37] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 60|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 60|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 97, False: 964] | | ------------------ ------------------ 610| 1.06k| } 611| 1.03k| return 1 + cl->nupvalues; 612| 1.03k|} lgc.c:traverseproto: 578| 7.33k|static int traverseproto (global_State *g, Proto *f) { 579| 7.33k| int i; 580| 7.33k| markobjectN(g, f->source); ------------------ | | 105| 7.33k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 7.33k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 7.33k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 7.33k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 1.00k, False: 6.33k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 1.00k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 1.00k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 7.33k, False: 0] | | ------------------ ------------------ 581| 156k| for (i = 0; i < f->sizek; i++) /* mark literals */ ------------------ | Branch (581:15): [True: 149k, False: 7.33k] ------------------ 582| 149k| markvalue(g, &f->k[i]); ------------------ | | 94| 149k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 149k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 149k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 149k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 149k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 149k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 298k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 149k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 149k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 59.9k, False: 89.2k] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 59.9k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 59.9k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 708, False: 59.2k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 708|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 708|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 583| 13.7k| for (i = 0; i < f->sizeupvalues; i++) /* mark upvalue names */ ------------------ | Branch (583:15): [True: 6.37k, False: 7.33k] ------------------ 584| 6.37k| markobjectN(g, f->upvalues[i].name); ------------------ | | 105| 6.37k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 2.94k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 2.94k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 2.94k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 20, False: 2.92k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 20|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 20|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 2.94k, False: 3.42k] | | ------------------ ------------------ 585| 16.0k| for (i = 0; i < f->sizep; i++) /* mark nested protos */ ------------------ | Branch (585:15): [True: 8.70k, False: 7.33k] ------------------ 586| 8.70k| markobjectN(g, f->p[i]); ------------------ | | 105| 8.70k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 6.33k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 6.33k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 6.33k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 6.31k, False: 25] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 6.31k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 6.31k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 6.33k, False: 2.37k] | | ------------------ ------------------ 587| 18.5k| for (i = 0; i < f->sizelocvars; i++) /* mark local-variable names */ ------------------ | Branch (587:15): [True: 11.2k, False: 7.33k] ------------------ 588| 11.2k| markobjectN(g, f->locvars[i].varname); ------------------ | | 105| 11.2k|#define markobjectN(g,t) { if (t) markobject(g,t); } | | ------------------ | | | | 99| 8.62k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 87| 8.62k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 8.62k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 108, False: 8.51k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | | | ------------------ | | | | | | 390| 108|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 108|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (105:32): [True: 8.62k, False: 2.60k] | | ------------------ ------------------ 589| 7.33k| return 1 + f->sizek + f->sizeupvalues + f->sizep + f->sizelocvars; 590| 7.33k|} lgc.c:traversethread: 627| 2.00k|static int traversethread (global_State *g, lua_State *th) { 628| 2.00k| UpVal *uv; 629| 2.00k| StkId o = th->stack.p; 630| 2.00k| if (isold(th) || g->gcstate == GCSpropagate) ------------------ | | 118| 4.01k|#define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 116| 2.00k|#define getage(o) ((o)->marked & AGEBITS) | | | | ------------------ | | | | | | 114| 2.00k|#define AGEBITS 7 /* all age bits (111) */ | | | | ------------------ | | ------------------ | | #define isold(o) (getage(o) > G_SURVIVAL) | | ------------------ | | | | 107| 2.00k|#define G_SURVIVAL 1 /* created in previous cycle */ | | ------------------ | | | Branch (118:18): [True: 0, False: 2.00k] | | ------------------ ------------------ if (isold(th) || g->gcstate == GCSpropagate) ------------------ | | 31| 2.00k|#define GCSpropagate 0 ------------------ | Branch (630:20): [True: 1.00k, False: 1.00k] ------------------ 631| 1.00k| linkgclist(th, g->grayagain); /* insert into 'grayagain' list */ ------------------ | | 146| 1.00k|#define linkgclist(o,p) linkgclist_(obj2gco(o), &(o)->gclist, &(p)) | | ------------------ | | | | 390| 1.00k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 1.00k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 632| 2.00k| if (o == NULL) ------------------ | Branch (632:7): [True: 0, False: 2.00k] ------------------ 633| 0| return 1; /* stack not completely built yet */ 634| 2.00k| lua_assert(g->gcstate == GCSatomic || ------------------ | | 114| 2.00k|#define lua_assert(c) ((void)0) ------------------ 635| 2.00k| th->openupval == NULL || isintwups(th)); 636| 1.34M| for (; o < th->top.p; o++) /* mark live elements in the stack */ ------------------ | Branch (636:10): [True: 1.33M, False: 2.00k] ------------------ 637| 1.33M| markvalue(g, s2v(o)); ------------------ | | 94| 1.34M|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 1.33M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 1.33M|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 1.33M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 1.34M| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 1.33M|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 2.67M|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 1.33M|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 1.33M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 12.1k, False: 1.32M] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 12.1k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 12.1k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 2.83k, False: 9.33k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 2.83k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 2.83k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 638| 2.04k| for (uv = th->openupval; uv != NULL; uv = uv->u.open.next) ------------------ | Branch (638:28): [True: 40, False: 2.00k] ------------------ 639| 40| markobject(g, uv); /* open upvalues cannot be collected */ ------------------ | | 99| 2.04k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 40|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 40|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 6, False: 34] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 6|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 6|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 640| 2.00k| if (g->gcstate == GCSatomic) { /* final traversal? */ ------------------ | | 33| 2.00k|#define GCSatomic 2 ------------------ | Branch (640:7): [True: 1.00k, False: 1.00k] ------------------ 641| 42.5k| for (; o < th->stack_last.p + EXTRA_STACK; o++) ------------------ | | 142| 42.5k|#define EXTRA_STACK 5 ------------------ | Branch (641:12): [True: 41.5k, False: 1.00k] ------------------ 642| 41.5k| setnilvalue(s2v(o)); /* clear dead stack slice */ ------------------ | | 200| 41.5k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 41.5k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 643| | /* 'remarkupvals' may have removed thread from 'twups' list */ 644| 1.00k| if (!isintwups(th) && th->openupval != NULL) { ------------------ | | 22| 2.00k|#define isintwups(L) (L->twups != L) ------------------ | Branch (644:9): [True: 984, False: 20] | Branch (644:27): [True: 0, False: 984] ------------------ 645| 0| th->twups = g->twups; /* link it back to the list */ 646| 0| g->twups = th; 647| 0| } 648| 1.00k| } 649| 1.00k| else if (!g->gcemergency) ------------------ | Branch (649:12): [True: 1.00k, False: 0] ------------------ 650| 1.00k| luaD_shrinkstack(th); /* do not change stack in emergency cycle */ 651| 2.00k| return 1 + stacksize(th); ------------------ | | 147| 2.00k|#define stacksize(th) cast_int((th)->stack_last.p - (th)->stack.p) | | ------------------ | | | | 141| 2.00k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 2.00k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 652| 2.00k|} lgc.c:remarkupvals: 367| 1.00k|static int remarkupvals (global_State *g) { 368| 1.00k| lua_State *thread; 369| 1.00k| lua_State **p = &g->twups; 370| 1.00k| int work = 0; /* estimate of how much work was done here */ 371| 1.02k| while ((thread = *p) != NULL) { ------------------ | Branch (371:10): [True: 20, False: 1.00k] ------------------ 372| 20| work++; 373| 20| if (!iswhite(thread) && thread->openupval != NULL) ------------------ | | 87| 20|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 40|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (373:9): [True: 20, False: 0] | Branch (373:29): [True: 20, False: 0] ------------------ 374| 20| p = &thread->twups; /* keep marked thread with upvalues in the list */ 375| 0| else { /* thread is not marked or without upvalues */ 376| 0| UpVal *uv; 377| 0| lua_assert(!isold(thread) || thread->openupval == NULL); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 378| 0| *p = thread->twups; /* remove thread from the list */ 379| 0| thread->twups = thread; /* mark that it is out of list */ 380| 0| for (uv = thread->openupval; uv != NULL; uv = uv->u.open.next) { ------------------ | Branch (380:36): [True: 0, False: 0] ------------------ 381| 0| lua_assert(getage(uv) <= getage(thread)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 382| 0| work++; 383| 0| if (!iswhite(uv)) { /* upvalue already visited? */ ------------------ | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | ------------------ ------------------ | Branch (383:13): [True: 0, False: 0] ------------------ 384| 0| lua_assert(upisopen(uv) && isgray(uv)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 385| 0| markvalue(g, uv->v.p); /* mark its value */ ------------------ | | 94| 0|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 0| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 0|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 386| 0| } 387| 0| } 388| 0| } 389| 20| } 390| 1.00k| return work; 391| 1.00k|} lgc.c:convergeephemerons: 689| 2.00k|static void convergeephemerons (global_State *g) { 690| 2.00k| int changed; 691| 2.00k| int dir = 0; 692| 2.00k| do { 693| 2.00k| GCObject *w; 694| 2.00k| GCObject *next = g->ephemeron; /* get ephemeron list */ 695| 2.00k| g->ephemeron = NULL; /* tables may return to this list when traversed */ 696| 2.00k| changed = 0; 697| 2.00k| while ((w = next) != NULL) { /* for each ephemeron table */ ------------------ | Branch (697:12): [True: 0, False: 2.00k] ------------------ 698| 0| Table *h = gco2t(w); ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 699| 0| next = h->gclist; /* list is rebuilt during loop */ 700| 0| nw2black(h); /* out of the list (for now) */ ------------------ | | 100| 0| check_exp(!iswhite(x), l_setbit((x)->marked, BLACKBIT)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 701| 0| if (traverseephemeron(g, h, dir)) { /* marked some value? */ ------------------ | Branch (701:11): [True: 0, False: 0] ------------------ 702| 0| propagateall(g); /* propagate changes */ 703| 0| changed = 1; /* will have to revisit all ephemeron tables */ 704| 0| } 705| 0| } 706| 2.00k| dir = !dir; /* invert direction next time */ 707| 2.00k| } while (changed); /* repeat until no more changes */ ------------------ | Branch (707:12): [True: 0, False: 2.00k] ------------------ 708| 2.00k|} lgc.c:clearbyvalues: 742| 4.01k|static void clearbyvalues (global_State *g, GCObject *l, GCObject *f) { 743| 4.01k| for (; l != f; l = gco2t(l)->gclist) { ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (743:10): [True: 0, False: 4.01k] ------------------ 744| 0| Table *h = gco2t(l); ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 745| 0| Node *n, *limit = gnodelast(h); ------------------ | | 122| 0|#define gnodelast(h) gnode(h, cast_sizet(sizenode(h))) | | ------------------ | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 746| 0| unsigned int i; 747| 0| unsigned int asize = luaH_realasize(h); 748| 0| for (i = 0; i < asize; i++) { ------------------ | Branch (748:17): [True: 0, False: 0] ------------------ 749| 0| TValue *o = &h->array[i]; 750| 0| if (iscleared(g, gcvalueN(o))) /* value was collected? */ ------------------ | | 91| 0|#define gcvalueN(o) (iscollectable(o) ? gcvalue(o) : NULL) | | ------------------ | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define gcvalueN(o) (iscollectable(o) ? gcvalue(o) : NULL) | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ | Branch (750:11): [True: 0, False: 0] ------------------ 751| 0| setempty(o); /* remove entry */ ------------------ | | 225| 0|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 752| 0| } 753| 0| for (n = gnode(h, 0); n < limit; n++) { ------------------ | | 13| 0|#define gnode(t,i) (&(t)->node[i]) ------------------ | Branch (753:27): [True: 0, False: 0] ------------------ 754| 0| if (iscleared(g, gcvalueN(gval(n)))) /* unmarked value? */ ------------------ | | 91| 0|#define gcvalueN(o) (iscollectable(o) ? gcvalue(o) : NULL) | | ------------------ | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define gcvalueN(o) (iscollectable(o) ? gcvalue(o) : NULL) | | ------------------ | | | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ | Branch (754:11): [True: 0, False: 0] ------------------ 755| 0| setempty(gval(n)); /* remove entry */ ------------------ | | 225| 0|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 756| 0| if (isempty(gval(n))) /* is entry empty? */ ------------------ | | 217| 0|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 757| 0| clearkey(n); /* clear its key */ 758| 0| } 759| 0| } 760| 4.01k|} lgc.c:markbeingfnz: 345| 2.00k|static lu_mem markbeingfnz (global_State *g) { 346| 2.00k| GCObject *o; 347| 2.00k| lu_mem count = 0; 348| 2.00k| for (o = g->tobefnz; o != NULL; o = o->next) { ------------------ | Branch (348:24): [True: 0, False: 2.00k] ------------------ 349| 0| count++; 350| 0| markobject(g, o); ------------------ | | 99| 0|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 351| 0| } 352| 2.00k| return count; 353| 2.00k|} lgc.c:clearbykeys: 723| 2.00k|static void clearbykeys (global_State *g, GCObject *l) { 724| 2.00k| for (; l; l = gco2t(l)->gclist) { ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (724:10): [True: 0, False: 2.00k] ------------------ 725| 0| Table *h = gco2t(l); ------------------ | | 380| 0|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 726| 0| Node *limit = gnodelast(h); ------------------ | | 122| 0|#define gnodelast(h) gnode(h, cast_sizet(sizenode(h))) | | ------------------ | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 727| 0| Node *n; 728| 0| for (n = gnode(h, 0); n < limit; n++) { ------------------ | | 13| 0|#define gnode(t,i) (&(t)->node[i]) ------------------ | Branch (728:27): [True: 0, False: 0] ------------------ 729| 0| if (iscleared(g, gckeyN(n))) /* unmarked key? */ ------------------ | | 769| 0|#define gckeyN(n) (keyiscollectable(n) ? gckey(n) : NULL) | | ------------------ | | | | 766| 0|#define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 755| 0|#define keytt(node) ((node)->u.key_tt) | | | | ------------------ | | | | #define keyiscollectable(n) (keytt(n) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (766:29): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | #define gckeyN(n) (keyiscollectable(n) ? gckey(n) : NULL) | | ------------------ | | | | 768| 0|#define gckey(n) (keyval(n).gc) | | | | ------------------ | | | | | | 756| 0|#define keyval(node) ((node)->u.key_val) | | | | ------------------ | | ------------------ ------------------ | Branch (729:11): [True: 0, False: 0] ------------------ 730| 0| setempty(gval(n)); /* remove entry */ ------------------ | | 225| 0|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 731| 0| if (isempty(gval(n))) /* is entry empty? */ ------------------ | | 217| 0|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 732| 0| clearkey(n); /* clear its key */ 733| 0| } 734| 0| } 735| 2.00k|} lgc.c:cleargraylists: 394| 1.00k|static void cleargraylists (global_State *g) { 395| 1.00k| g->gray = g->grayagain = NULL; 396| 1.00k| g->weak = g->allweak = g->ephemeron = NULL; 397| 1.00k|} lgc.c:checkSizes: 869| 1.00k|static void checkSizes (lua_State *L, global_State *g) { 870| 1.00k| if (!g->gcemergency) { ------------------ | Branch (870:7): [True: 1.00k, False: 0] ------------------ 871| 1.00k| if (g->strt.nuse < g->strt.size / 4) { /* string table too big? */ ------------------ | Branch (871:9): [True: 22, False: 982] ------------------ 872| 22| l_mem olddebt = g->GCdebt; 873| 22| luaS_resize(L, g->strt.size / 2); 874| 22| g->GCestimate += g->GCdebt - olddebt; /* correct estimate */ 875| 22| } 876| 1.00k| } 877| 1.00k|} lgc.c:separatetobefnz: 972| 1.26k|static void separatetobefnz (global_State *g, int all) { 973| 1.26k| GCObject *curr; 974| 1.26k| GCObject **p = &g->finobj; 975| 1.26k| GCObject **lastnext = findlast(&g->tobefnz); 976| 1.27k| while ((curr = *p) != g->finobjold1) { /* traverse all finalizable objects */ ------------------ | Branch (976:10): [True: 11, False: 1.26k] ------------------ 977| 11| lua_assert(tofinalize(curr)); ------------------ | | 114| 11|#define lua_assert(c) ((void)0) ------------------ 978| 11| if (!(iswhite(curr) || all)) /* not being collected? */ ------------------ | | 87| 11|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 22|#define testbits(x,m) ((x) & (m)) | | | | ------------------ | | | | | Branch (62:24): [True: 11, False: 0] | | | | ------------------ | | ------------------ ------------------ | Branch (978:28): [True: 0, False: 0] ------------------ 979| 0| p = &curr->next; /* don't bother with it */ 980| 11| else { 981| 11| if (curr == g->finobjsur) /* removing 'finobjsur'? */ ------------------ | Branch (981:11): [True: 0, False: 11] ------------------ 982| 0| g->finobjsur = curr->next; /* correct it */ 983| 11| *p = curr->next; /* remove 'curr' from 'finobj' list */ 984| 11| curr->next = *lastnext; /* link at the end of 'tobefnz' list */ 985| 11| *lastnext = curr; 986| 11| lastnext = &curr->next; 987| 11| } 988| 11| } 989| 1.26k|} lgc.c:findlast: 958| 1.26k|static GCObject **findlast (GCObject **p) { 959| 1.26k| while (*p != NULL) ------------------ | Branch (959:10): [True: 0, False: 1.26k] ------------------ 960| 0| p = &(*p)->next; 961| 1.26k| return p; 962| 1.26k|} lgc.c:callallpendingfinalizers: 948| 258|static void callallpendingfinalizers (lua_State *L) { 949| 258| global_State *g = G(L); ------------------ | | 335| 258|#define G(L) (L->l_G) ------------------ 950| 269| while (g->tobefnz) ------------------ | Branch (950:10): [True: 11, False: 258] ------------------ 951| 11| GCTM(L); 952| 258|} lgc.c:GCTM: 905| 11|static void GCTM (lua_State *L) { 906| 11| global_State *g = G(L); ------------------ | | 335| 11|#define G(L) (L->l_G) ------------------ 907| 11| const TValue *tm; 908| 11| TValue v; 909| 11| lua_assert(!g->gcemergency); ------------------ | | 114| 11|#define lua_assert(c) ((void)0) ------------------ 910| 11| setgcovalue(L, &v, udata2finalize(g)); ------------------ | | 310| 11| { TValue *io = (obj); GCObject *i_g=(x); \ | | 311| 11| val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); } | | ------------------ | | | | 72| 11|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); } | | ------------------ | | | | 114| 11|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 911| 11| tm = luaT_gettmbyobj(L, &v, TM_GC); 912| 11| if (!notm(tm)) { /* is there a finalizer? */ ------------------ | | 62| 11|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 193| 11|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 11|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 11|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 11|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (912:7): [True: 11, False: 0] ------------------ 913| 11| int status; 914| 11| lu_byte oldah = L->allowhook; 915| 11| int oldgcstp = g->gcstp; 916| 11| g->gcstp |= GCSTPGC; /* avoid GC steps */ ------------------ | | 156| 11|#define GCSTPGC 2 /* bit true when GC stopped by itself */ ------------------ 917| 11| L->allowhook = 0; /* stop debug hooks during GC metamethod */ 918| 11| setobj2s(L, L->top.p++, tm); /* push finalizer... */ ------------------ | | 131| 11|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 11| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 11| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 11|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 11| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 11| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 11|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 11| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 919| 11| setobj2s(L, L->top.p++, &v); /* ... and its argument */ ------------------ | | 131| 11|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 11| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 11| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 11|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 11| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 11| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 11|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 11| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 11|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 920| 11| L->ci->callstatus |= CIST_FIN; /* will run a finalizer */ ------------------ | | 217| 11|#define CIST_FIN (1<<7) /* function "called" a finalizer */ ------------------ 921| 11| status = luaD_pcall(L, dothecall, NULL, savestack(L, L->top.p - 2), 0); ------------------ | | 36| 11|#define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 11|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 11|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | #define savestack(L,pt) (cast_charp(pt) - cast_charp(L->stack.p)) | | ------------------ | | | | 146| 11|#define cast_charp(i) cast(char *, (i)) | | | | ------------------ | | | | | | 136| 11|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 922| 11| L->ci->callstatus &= ~CIST_FIN; /* not running a finalizer anymore */ ------------------ | | 217| 11|#define CIST_FIN (1<<7) /* function "called" a finalizer */ ------------------ 923| 11| L->allowhook = oldah; /* restore hooks */ 924| 11| g->gcstp = oldgcstp; /* restore state */ 925| 11| if (l_unlikely(status != LUA_OK)) { /* error while running __gc? */ ------------------ | | 688| 11|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 11|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 11] | | | | ------------------ | | ------------------ ------------------ 926| 0| luaE_warnerror(L, "__gc"); 927| 0| L->top.p--; /* pops error object */ 928| 0| } 929| 11| } 930| 11|} lgc.c:udata2finalize: 884| 11|static GCObject *udata2finalize (global_State *g) { 885| 11| GCObject *o = g->tobefnz; /* get first element */ 886| 11| lua_assert(tofinalize(o)); ------------------ | | 114| 11|#define lua_assert(c) ((void)0) ------------------ 887| 11| g->tobefnz = o->next; /* remove it from 'tobefnz' list */ 888| 11| o->next = g->allgc; /* return it to 'allgc' list */ 889| 11| g->allgc = o; 890| 11| resetbit(o->marked, FINALIZEDBIT); /* object is "normal" again */ ------------------ | | 66| 11|#define resetbit(x,b) resetbits(x, bitmask(b)) | | ------------------ | | | | 60| 11|#define resetbits(x,m) ((x) &= cast_byte(~(m))) | | | | ------------------ | | | | | | 143| 11|#define cast_byte(i) cast(lu_byte, (i)) | | | | | | ------------------ | | | | | | | | 136| 11|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 891| 11| if (issweepphase(g)) ------------------ | | 43| 11| (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 34| 11|#define GCSswpallgc 3 | | ------------------ | | (GCSswpallgc <= (g)->gcstate && (g)->gcstate <= GCSswpend) | | ------------------ | | | | 37| 11|#define GCSswpend 6 | | ------------------ | | | Branch (43:3): [True: 11, False: 0] | | | Branch (43:34): [True: 0, False: 11] | | ------------------ ------------------ 892| 0| makewhite(g, o); /* "sweep" object */ ------------------ | | 72| 0| (x->marked = cast_byte((x->marked & ~maskcolors) | luaC_white(g))) | | ------------------ | | | | 143| 0|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 893| 11| else if (getage(o) == G_OLD1) ------------------ | | 116| 11|#define getage(o) ((o)->marked & AGEBITS) | | ------------------ | | | | 114| 11|#define AGEBITS 7 /* all age bits (111) */ | | ------------------ ------------------ else if (getage(o) == G_OLD1) ------------------ | | 109| 11|#define G_OLD1 3 /* first full cycle as old */ ------------------ | Branch (893:12): [True: 0, False: 11] ------------------ 894| 0| g->firstold1 = o; /* it is the first OLD1 object in the list */ 895| 11| return o; 896| 11|} lgc.c:dothecall: 899| 11|static void dothecall (lua_State *L, void *ud) { 900| 11| UNUSED(ud); ------------------ | | 131| 11|#define UNUSED(x) ((void)(x)) ------------------ 901| 11| luaD_callnoyield(L, L->top.p - 2, 0); 902| 11|} lgc.c:deletelist: 1496| 516|static void deletelist (lua_State *L, GCObject *p, GCObject *limit) { 1497| 82.5k| while (p != limit) { ------------------ | Branch (1497:10): [True: 82.0k, False: 516] ------------------ 1498| 82.0k| GCObject *next = p->next; 1499| 82.0k| freeobj(L, p); 1500| 82.0k| p = next; 1501| 82.0k| } 1502| 516|} lgc.c:singlestep: 1583| 26.8k|static lu_mem singlestep (lua_State *L) { 1584| 26.8k| global_State *g = G(L); ------------------ | | 335| 26.8k|#define G(L) (L->l_G) ------------------ 1585| 26.8k| lu_mem work; 1586| 26.8k| lua_assert(!g->gcstopem); /* collector is not reentrant */ ------------------ | | 114| 26.8k|#define lua_assert(c) ((void)0) ------------------ 1587| 26.8k| g->gcstopem = 1; /* no emergency collections while collecting */ 1588| 26.8k| switch (g->gcstate) { 1589| 1.00k| case GCSpause: { ------------------ | | 39| 1.00k|#define GCSpause 8 ------------------ | Branch (1589:5): [True: 1.00k, False: 25.8k] ------------------ 1590| 1.00k| restartcollection(g); 1591| 1.00k| g->gcstate = GCSpropagate; ------------------ | | 31| 1.00k|#define GCSpropagate 0 ------------------ 1592| 1.00k| work = 1; 1593| 1.00k| break; 1594| 0| } 1595| 13.3k| case GCSpropagate: { ------------------ | | 31| 13.3k|#define GCSpropagate 0 ------------------ | Branch (1595:5): [True: 13.3k, False: 13.4k] ------------------ 1596| 13.3k| if (g->gray == NULL) { /* no more gray objects? */ ------------------ | Branch (1596:11): [True: 1.00k, False: 12.3k] ------------------ 1597| 1.00k| g->gcstate = GCSenteratomic; /* finish propagate phase */ ------------------ | | 32| 1.00k|#define GCSenteratomic 1 ------------------ 1598| 1.00k| work = 0; 1599| 1.00k| } 1600| 12.3k| else 1601| 12.3k| work = propagatemark(g); /* traverse one gray object */ 1602| 13.3k| break; 1603| 0| } 1604| 1.00k| case GCSenteratomic: { ------------------ | | 32| 1.00k|#define GCSenteratomic 1 ------------------ | Branch (1604:5): [True: 1.00k, False: 25.8k] ------------------ 1605| 1.00k| work = atomic(L); /* work is what was traversed by 'atomic' */ 1606| 1.00k| entersweep(L); 1607| 1.00k| g->GCestimate = gettotalbytes(g); /* first estimate */; ------------------ | | 394| 1.00k|#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) | | ------------------ | | | | 136| 1.00k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1608| 1.00k| break; 1609| 0| } 1610| 5.46k| case GCSswpallgc: { /* sweep "regular" objects */ ------------------ | | 34| 5.46k|#define GCSswpallgc 3 ------------------ | Branch (1610:5): [True: 5.46k, False: 21.4k] ------------------ 1611| 5.46k| work = sweepstep(L, g, GCSswpfinobj, &g->finobj); ------------------ | | 35| 5.46k|#define GCSswpfinobj 4 ------------------ 1612| 5.46k| break; 1613| 0| } 1614| 2.00k| case GCSswpfinobj: { /* sweep objects with finalizers */ ------------------ | | 35| 2.00k|#define GCSswpfinobj 4 ------------------ | Branch (1614:5): [True: 2.00k, False: 24.8k] ------------------ 1615| 2.00k| work = sweepstep(L, g, GCSswptobefnz, &g->tobefnz); ------------------ | | 36| 2.00k|#define GCSswptobefnz 5 ------------------ 1616| 2.00k| break; 1617| 0| } 1618| 2.00k| case GCSswptobefnz: { /* sweep objects to be finalized */ ------------------ | | 36| 2.00k|#define GCSswptobefnz 5 ------------------ | Branch (1618:5): [True: 2.00k, False: 24.8k] ------------------ 1619| 2.00k| work = sweepstep(L, g, GCSswpend, NULL); ------------------ | | 37| 2.00k|#define GCSswpend 6 ------------------ 1620| 2.00k| break; 1621| 0| } 1622| 1.00k| case GCSswpend: { /* finish sweeps */ ------------------ | | 37| 1.00k|#define GCSswpend 6 ------------------ | Branch (1622:5): [True: 1.00k, False: 25.8k] ------------------ 1623| 1.00k| checkSizes(L, g); 1624| 1.00k| g->gcstate = GCScallfin; ------------------ | | 38| 1.00k|#define GCScallfin 7 ------------------ 1625| 1.00k| work = 0; 1626| 1.00k| break; 1627| 0| } 1628| 1.00k| case GCScallfin: { /* call remaining finalizers */ ------------------ | | 38| 1.00k|#define GCScallfin 7 ------------------ | Branch (1628:5): [True: 1.00k, False: 25.8k] ------------------ 1629| 1.00k| if (g->tobefnz && !g->gcemergency) { ------------------ | Branch (1629:11): [True: 0, False: 1.00k] | Branch (1629:25): [True: 0, False: 0] ------------------ 1630| 0| g->gcstopem = 0; /* ok collections during finalizers */ 1631| 0| work = runafewfinalizers(L, GCFINMAX) * GCFINALIZECOST; ------------------ | | 40| 0|#define GCFINMAX 10 ------------------ work = runafewfinalizers(L, GCFINMAX) * GCFINALIZECOST; ------------------ | | 46| 0|#define GCFINALIZECOST 50 ------------------ 1632| 0| } 1633| 1.00k| else { /* emergency mode or no more finalizers */ 1634| 1.00k| g->gcstate = GCSpause; /* finish collection */ ------------------ | | 39| 1.00k|#define GCSpause 8 ------------------ 1635| 1.00k| work = 0; 1636| 1.00k| } 1637| 1.00k| break; 1638| 0| } 1639| 0| default: lua_assert(0); return 0; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (1639:5): [True: 0, False: 26.8k] ------------------ 1640| 26.8k| } 1641| 26.8k| g->gcstopem = 0; 1642| 26.8k| return work; 1643| 26.8k|} lgc.c:restartcollection: 403| 1.00k|static void restartcollection (global_State *g) { 404| 1.00k| cleargraylists(g); 405| 1.00k| markobject(g, g->mainthread); ------------------ | | 99| 1.00k|#define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 87| 1.00k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 1.00k|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 1.00k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define markobject(g,t) { if (iswhite(t)) reallymarkobject(g, obj2gco(t)); } | | ------------------ | | | | 390| 1.00k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 1.00k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 406| 1.00k| markvalue(g, &g->l_registry); ------------------ | | 94| 1.00k|#define markvalue(g,o) { checkliveness(g->mainthread,o); \ | | ------------------ | | | | 107| 1.00k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 1.00k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 1.00k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | 95| 1.00k| if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 83| 1.00k|#define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 300| 2.00k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 1.00k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 1.00k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 1.00k, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | #define valiswhite(x) (iscollectable(x) && iswhite(gcvalue(x))) | | | | ------------------ | | | | | | 87| 1.00k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 1.00k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 1.00k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (valiswhite(o)) reallymarkobject(g,gcvalue(o)); } | | ------------------ | | | | 305| 1.00k|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | | | ------------------ | | | | | | 115| 1.00k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 407| 1.00k| markmt(g); 408| 1.00k| markbeingfnz(g); /* mark any finalizing object left from previous cycle */ 409| 1.00k|} lgc.c:entersweep: 1484| 1.00k|static void entersweep (lua_State *L) { 1485| 1.00k| global_State *g = G(L); ------------------ | | 335| 1.00k|#define G(L) (L->l_G) ------------------ 1486| 1.00k| g->gcstate = GCSswpallgc; ------------------ | | 34| 1.00k|#define GCSswpallgc 3 ------------------ 1487| 1.00k| lua_assert(g->sweepgc == NULL); ------------------ | | 114| 1.00k|#define lua_assert(c) ((void)0) ------------------ 1488| 1.00k| g->sweepgc = sweeptolive(L, &g->allgc); 1489| 1.00k|} lgc.c:sweepstep: 1567| 9.48k| int nextstate, GCObject **nextlist) { 1568| 9.48k| if (g->sweepgc) { ------------------ | Branch (1568:7): [True: 6.47k, False: 3.01k] ------------------ 1569| 6.47k| l_mem olddebt = g->GCdebt; 1570| 6.47k| int count; 1571| 6.47k| g->sweepgc = sweeplist(L, g->sweepgc, GCSWEEPMAX, &count); ------------------ | | 35| 6.47k|#define GCSWEEPMAX 100 ------------------ 1572| 6.47k| g->GCestimate += g->GCdebt - olddebt; /* update estimate */ 1573| 6.47k| return count; 1574| 6.47k| } 1575| 3.01k| else { /* enter next state */ 1576| 3.01k| g->gcstate = nextstate; 1577| 3.01k| g->sweepgc = nextlist; 1578| 3.01k| return 0; /* no work done */ 1579| 3.01k| } 1580| 9.48k|} lgc.c:setpause: 1057| 1.00k|static void setpause (global_State *g) { 1058| 1.00k| l_mem threshold, debt; 1059| 1.00k| int pause = getgcparam(g->gcpause); ------------------ | | 135| 1.00k|#define getgcparam(p) ((p) * 4) ------------------ 1060| 1.00k| l_mem estimate = g->GCestimate / PAUSEADJ; /* adjust 'estimate' */ ------------------ | | 60| 1.00k|#define PAUSEADJ 100 ------------------ 1061| 1.00k| lua_assert(estimate > 0); ------------------ | | 114| 1.00k|#define lua_assert(c) ((void)0) ------------------ 1062| 1.00k| threshold = (pause < MAX_LMEM / estimate) /* overflow? */ ------------------ | | 50| 1.00k|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 1.00k|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ | Branch (1062:15): [True: 1.00k, False: 0] ------------------ 1063| 1.00k| ? estimate * pause /* no overflow */ 1064| 1.00k| : MAX_LMEM; /* overflow; truncate to maximum */ ------------------ | | 50| 1.00k|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 0|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ 1065| 1.00k| debt = gettotalbytes(g) - threshold; ------------------ | | 394| 1.00k|#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) | | ------------------ | | | | 136| 1.00k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1066| 1.00k| if (debt > 0) debt = 0; ------------------ | Branch (1066:7): [True: 0, False: 1.00k] ------------------ 1067| 1.00k| luaE_setdebt(g, debt); 1068| 1.00k|} lgc.c:incstep: 1665| 1.01k|static void incstep (lua_State *L, global_State *g) { 1666| 1.01k| int stepmul = (getgcparam(g->gcstepmul) | 1); /* avoid division by 0 */ ------------------ | | 135| 1.01k|#define getgcparam(p) ((p) * 4) ------------------ 1667| 1.01k| l_mem debt = (g->GCdebt / WORK2MEM) * stepmul; ------------------ | | 53| 1.01k|#define WORK2MEM sizeof(TValue) ------------------ 1668| 1.01k| l_mem stepsize = (g->gcstepsize <= log2maxs(l_mem)) ------------------ | | 60| 1.01k|#define log2maxs(t) (sizeof(t) * 8 - 2) ------------------ | Branch (1668:20): [True: 1.01k, False: 0] ------------------ 1669| 1.01k| ? ((cast(l_mem, 1) << g->gcstepsize) / WORK2MEM) * stepmul ------------------ | | 136| 1.01k|#define cast(t, exp) ((t)(exp)) ------------------ ? ((cast(l_mem, 1) << g->gcstepsize) / WORK2MEM) * stepmul ------------------ | | 53| 1.01k|#define WORK2MEM sizeof(TValue) ------------------ 1670| 1.01k| : MAX_LMEM; /* overflow; keep maximum value */ ------------------ | | 50| 1.01k|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 0|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ 1671| 26.8k| do { /* repeat until pause or enough "credit" (negative debt) */ 1672| 26.8k| lu_mem work = singlestep(L); /* perform one single step */ 1673| 26.8k| debt -= work; 1674| 26.8k| } while (debt > -stepsize && g->gcstate != GCSpause); ------------------ | | 39| 26.8k|#define GCSpause 8 ------------------ | Branch (1674:12): [True: 26.8k, False: 13] | Branch (1674:32): [True: 25.8k, False: 1.00k] ------------------ 1675| 1.01k| if (g->gcstate == GCSpause) ------------------ | | 39| 1.01k|#define GCSpause 8 ------------------ | Branch (1675:7): [True: 1.00k, False: 13] ------------------ 1676| 1.00k| setpause(g); /* pause until next cycle */ 1677| 13| else { 1678| 13| debt = (debt / stepmul) * WORK2MEM; /* convert 'work units' to bytes */ ------------------ | | 53| 13|#define WORK2MEM sizeof(TValue) ------------------ 1679| 13| luaE_setdebt(g, debt); 1680| 13| } 1681| 1.01k|} luaX_init: 70| 258|void luaX_init (lua_State *L) { 71| 258| int i; 72| 258| TString *e = luaS_newliteral(L, LUA_ENV); /* create env name */ ------------------ | | 28| 258|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 258| (sizeof(s)/sizeof(char))-1)) ------------------ 73| 258| luaC_fix(L, obj2gco(e)); /* never collect this name */ ------------------ | | 390| 258|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 258|#define check_exp(c,e) (e) | | ------------------ ------------------ 74| 5.93k| for (i=0; itt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 5.67k|#define check_exp(c,e) (e) | | ------------------ ------------------ 77| 5.67k| ts->extra = cast_byte(i+1); /* reserved word */ ------------------ | | 143| 5.67k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 5.67k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 78| 5.67k| } 79| 258|} luaX_token2str: 82| 242|const char *luaX_token2str (LexState *ls, int token) { 83| 242| if (token < FIRST_RESERVED) { /* single-byte symbols? */ ------------------ | | 20| 242|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ | Branch (83:7): [True: 155, False: 87] ------------------ 84| 155| if (lisprint(token)) ------------------ | | 61| 155|#define lisprint(c) testprop(c, MASK(PRINTBIT)) | | ------------------ | | | | 52| 155|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 104, False: 51] | | | | ------------------ | | ------------------ ------------------ 85| 104| return luaO_pushfstring(ls->L, "'%c'", token); 86| 51| else /* control character */ 87| 51| return luaO_pushfstring(ls->L, "'<\\%d>'", token); 88| 155| } 89| 87| else { 90| 87| const char *s = luaX_tokens[token - FIRST_RESERVED]; ------------------ | | 20| 87|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ 91| 87| if (token < TK_EOS) /* fixed format (symbols and reserved words)? */ ------------------ | Branch (91:9): [True: 35, False: 52] ------------------ 92| 35| return luaO_pushfstring(ls->L, "'%s'", s); 93| 52| else /* names, strings, and numerals */ 94| 52| return s; 95| 87| } 96| 242|} luaX_syntaxerror: 119| 159|l_noret luaX_syntaxerror (LexState *ls, const char *msg) { 120| 159| lexerror(ls, msg, ls->t.token); 121| 159|} luaX_newstring: 134| 7.54M|TString *luaX_newstring (LexState *ls, const char *str, size_t l) { 135| 7.54M| lua_State *L = ls->L; 136| 7.54M| TString *ts = luaS_newlstr(L, str, l); /* create new string */ 137| 7.54M| const TValue *o = luaH_getstr(ls->h, ts); 138| 7.54M| if (!ttisnil(o)) /* string already present? */ ------------------ | | 193| 7.54M|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 7.54M|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 7.54M|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 7.54M|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (138:7): [True: 7.53M, False: 16.3k] ------------------ 139| 7.53M| ts = keystrval(nodefromval(o)); /* get saved copy */ ------------------ | | 762| 7.53M|#define keystrval(node) (gco2ts(keyval(node).gc)) | | ------------------ | | | | 374| 7.53M| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | | | ------------------ | | | | | | 115| 7.53M|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 140| 16.3k| else { /* not in use yet */ 141| 16.3k| TValue *stv = s2v(L->top.p++); /* reserve stack space for string */ ------------------ | | 172| 16.3k|#define s2v(o) (&(o)->val) ------------------ 142| 16.3k| setsvalue(L, stv, ts); /* temporarily anchor the string */ ------------------ | | 372| 16.3k| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 16.3k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 16.3k|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 16.3k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 16.3k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 16.3k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 16.3k| checkliveness(L,io); } | | ------------------ | | | | 107| 16.3k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 16.3k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 16.3k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 143| 16.3k| luaH_finishset(L, ls->h, stv, o, stv); /* t[string] = string */ 144| | /* table is not a metatable, so it does not need to invalidate cache */ 145| 16.3k| luaC_checkGC(L); ------------------ | | 172| 16.3k|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 16.3k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 16.3k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 922, False: 15.4k] | | | | ------------------ | | | | 169| 16.3k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 16.3k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 146| 16.3k| L->top.p--; /* remove string from stack */ 147| 16.3k| } 148| 7.54M| return ts; 149| 7.54M|} luaX_setinput: 168| 258| int firstchar) { 169| 258| ls->t.token = 0; 170| 258| ls->L = L; 171| 258| ls->current = firstchar; 172| 258| ls->lookahead.token = TK_EOS; /* no look-ahead token */ 173| 258| ls->z = z; 174| 258| ls->fs = NULL; 175| 258| ls->linenumber = 1; 176| 258| ls->lastline = 1; 177| 258| ls->source = source; 178| 258| ls->envn = luaS_newliteral(L, LUA_ENV); /* get env name */ ------------------ | | 28| 258|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 258| (sizeof(s)/sizeof(char))-1)) ------------------ 179| 258| luaZ_resizebuffer(ls->L, ls->buff, LUA_MINBUFFER); /* initialize buffer */ ------------------ | | 40| 258| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | ------------------ | | | | 53| 258| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | ------------------ | | | | | | 146| 258|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 41| 258| (buff)->buffsize, size), \ | | 42| 258| (buff)->buffsize = size) ------------------ 180| 258|} luaX_next: 565| 15.3M|void luaX_next (LexState *ls) { 566| 15.3M| ls->lastline = ls->linenumber; 567| 15.3M| if (ls->lookahead.token != TK_EOS) { /* is there a look-ahead token? */ ------------------ | Branch (567:7): [True: 209, False: 15.3M] ------------------ 568| 209| ls->t = ls->lookahead; /* use this one */ 569| 209| ls->lookahead.token = TK_EOS; /* and discharge it */ 570| 209| } 571| 15.3M| else 572| 15.3M| ls->t.token = llex(ls, &ls->t.seminfo); /* read next token */ 573| 15.3M|} luaX_lookahead: 576| 209|int luaX_lookahead (LexState *ls) { 577| 209| lua_assert(ls->lookahead.token == TK_EOS); ------------------ | | 114| 209|#define lua_assert(c) ((void)0) ------------------ 578| 209| ls->lookahead.token = llex(ls, &ls->lookahead.seminfo); 579| 209| return ls->lookahead.token; 580| 209|} llex.c:lexerror: 111| 216|static l_noret lexerror (LexState *ls, const char *msg, int token) { 112| 216| msg = luaG_addinfo(ls->L, msg, ls->source, ls->linenumber); 113| 216| if (token) ------------------ | Branch (113:7): [True: 204, False: 12] ------------------ 114| 204| luaO_pushfstring(ls->L, "%s near %s", msg, txtToken(ls, token)); 115| 216| luaD_throw(ls->L, LUA_ERRSYNTAX); ------------------ | | 52| 216|#define LUA_ERRSYNTAX 3 ------------------ 116| 216|} llex.c:txtToken: 99| 204|static const char *txtToken (LexState *ls, int token) { 100| 204| switch (token) { 101| 40| case TK_NAME: case TK_STRING: ------------------ | Branch (101:5): [True: 8, False: 196] | Branch (101:19): [True: 32, False: 172] ------------------ 102| 53| case TK_FLT: case TK_INT: ------------------ | Branch (102:5): [True: 12, False: 192] | Branch (102:18): [True: 1, False: 203] ------------------ 103| 53| save(ls, '\0'); 104| 53| return luaO_pushfstring(ls->L, "'%s'", luaZ_buffer(ls->buff)); ------------------ | | 31| 53|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 105| 151| default: ------------------ | Branch (105:5): [True: 151, False: 53] ------------------ 106| 151| return luaX_token2str(ls, token); 107| 204| } 108| 204|} llex.c:save: 57| 24.4M|static void save (LexState *ls, int c) { 58| 24.4M| Mbuffer *b = ls->buff; 59| 24.4M| if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { ------------------ | | 33| 24.4M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ if (luaZ_bufflen(b) + 1 > luaZ_sizebuffer(b)) { ------------------ | | 32| 24.4M|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ | Branch (59:7): [True: 1.04k, False: 24.4M] ------------------ 60| 1.04k| size_t newsize; 61| 1.04k| if (luaZ_sizebuffer(b) >= MAX_SIZE/2) ------------------ | | 32| 1.04k|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ if (luaZ_sizebuffer(b) >= MAX_SIZE/2) ------------------ | | 44| 1.04k|#define MAX_SIZE (sizeof(size_t) < sizeof(lua_Integer) ? MAX_SIZET \ | | ------------------ | | | | 41| 0|#define MAX_SIZET ((size_t)(~(size_t)0)) | | ------------------ | | | Branch (44:19): [Folded - Ignored] | | ------------------ | | 45| 1.04k| : (size_t)(LUA_MAXINTEGER)) | | ------------------ | | | | 545| 1.04k|#define LUA_MAXINTEGER LLONG_MAX | | ------------------ ------------------ | Branch (61:9): [True: 0, False: 1.04k] ------------------ 62| 0| lexerror(ls, "lexical element too long", 0); 63| 1.04k| newsize = luaZ_sizebuffer(b) * 2; ------------------ | | 32| 1.04k|#define luaZ_sizebuffer(buff) ((buff)->buffsize) ------------------ 64| 1.04k| luaZ_resizebuffer(ls->L, b, newsize); ------------------ | | 40| 1.04k| ((buff)->buffer = luaM_reallocvchar(L, (buff)->buffer, \ | | ------------------ | | | | 53| 1.04k| cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char))) | | | | ------------------ | | | | | | 146| 1.04k|#define cast_charp(i) cast(char *, (i)) | | | | | | ------------------ | | | | | | | | 136| 1.04k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 41| 1.04k| (buff)->buffsize, size), \ | | 42| 1.04k| (buff)->buffsize = size) ------------------ 65| 1.04k| } 66| 24.4M| b->buffer[luaZ_bufflen(b)++] = cast_char(c); ------------------ | | 33| 24.4M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ b->buffer[luaZ_bufflen(b)++] = cast_char(c); ------------------ | | 145| 24.4M|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 136| 24.4M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 67| 24.4M|} llex.c:llex: 445| 15.3M|static int llex (LexState *ls, SemInfo *seminfo) { 446| 15.3M| luaZ_resetbuffer(ls->buff); ------------------ | | 36| 15.3M|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 447| 15.5M| for (;;) { 448| 15.5M| switch (ls->current) { 449| 113k| case '\n': case '\r': { /* line breaks */ ------------------ | Branch (449:7): [True: 85.7k, False: 15.4M] | Branch (449:18): [True: 27.7k, False: 15.5M] ------------------ 450| 113k| inclinenumber(ls); 451| 113k| break; 452| 85.7k| } 453| 73.2k| case ' ': case '\f': case '\t': case '\v': { /* spaces */ ------------------ | Branch (453:7): [True: 15.7k, False: 15.5M] | Branch (453:17): [True: 10.9k, False: 15.5M] | Branch (453:28): [True: 37.3k, False: 15.5M] | Branch (453:39): [True: 9.18k, False: 15.5M] ------------------ 454| 73.2k| next(ls); ------------------ | | 32| 73.2k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 73.2k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 73.2k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 73.2k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 73.2k, False: 0] | | | | ------------------ | | ------------------ ------------------ 455| 73.2k| break; 456| 64.0k| } 457| 157k| case '-': { /* '-' or '--' (comment) */ ------------------ | Branch (457:7): [True: 157k, False: 15.4M] ------------------ 458| 157k| next(ls); ------------------ | | 32| 157k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 157k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 157k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 157k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 157k, False: 0] | | | | ------------------ | | ------------------ ------------------ 459| 157k| if (ls->current != '-') return '-'; ------------------ | Branch (459:13): [True: 132k, False: 25.5k] ------------------ 460| | /* else is a comment */ 461| 25.5k| next(ls); ------------------ | | 32| 25.5k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 25.5k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 25.5k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 25.5k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 25.5k, False: 1] | | | | ------------------ | | ------------------ ------------------ 462| 25.5k| if (ls->current == '[') { /* long comment? */ ------------------ | Branch (462:13): [True: 514, False: 25.0k] ------------------ 463| 514| size_t sep = skip_sep(ls); 464| 514| luaZ_resetbuffer(ls->buff); /* 'skip_sep' may dirty the buffer */ ------------------ | | 36| 514|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 465| 514| if (sep >= 2) { ------------------ | Branch (465:15): [True: 38, False: 476] ------------------ 466| 38| read_long_string(ls, NULL, sep); /* skip long comment */ 467| 38| luaZ_resetbuffer(ls->buff); /* previous call may dirty the buff. */ ------------------ | | 36| 38|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ 468| 38| break; 469| 38| } 470| 514| } 471| | /* else short comment */ 472| 3.59M| while (!currIsNewline(ls) && ls->current != EOZ) ------------------ | | 36| 7.19M|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 10.5k, False: 3.58M] | | | Branch (36:51): [True: 14.9k, False: 3.57M] | | ------------------ ------------------ while (!currIsNewline(ls) && ls->current != EOZ) ------------------ | | 16| 3.57M|#define EOZ (-1) /* end of stream */ ------------------ | Branch (472:38): [True: 3.57M, False: 12] ------------------ 473| 3.57M| next(ls); /* skip until end of line (or end of file) */ ------------------ | | 32| 3.59M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 3.57M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 3.57M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 3.57M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 3.57M, False: 11] | | | | ------------------ | | ------------------ ------------------ 474| 25.4k| break; 475| 25.5k| } 476| 100k| case '[': { /* long string or simply '[' */ ------------------ | Branch (476:7): [True: 100k, False: 15.4M] ------------------ 477| 100k| size_t sep = skip_sep(ls); 478| 100k| if (sep >= 2) { ------------------ | Branch (478:13): [True: 88.4k, False: 12.1k] ------------------ 479| 88.4k| read_long_string(ls, seminfo, sep); 480| 88.4k| return TK_STRING; 481| 88.4k| } 482| 12.1k| else if (sep == 0) /* '[=...' missing second bracket? */ ------------------ | Branch (482:18): [True: 2, False: 12.1k] ------------------ 483| 2| lexerror(ls, "invalid long string delimiter", TK_STRING); 484| 12.1k| return '['; 485| 100k| } 486| 23.9k| case '=': { ------------------ | Branch (486:7): [True: 23.9k, False: 15.5M] ------------------ 487| 23.9k| next(ls); ------------------ | | 32| 23.9k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 23.9k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 23.9k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 23.9k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 23.9k, False: 0] | | | | ------------------ | | ------------------ ------------------ 488| 23.9k| if (check_next1(ls, '=')) return TK_EQ; /* '==' */ ------------------ | Branch (488:13): [True: 1.41k, False: 22.5k] ------------------ 489| 22.5k| else return '='; 490| 23.9k| } 491| 3.80M| case '<': { ------------------ | Branch (491:7): [True: 3.80M, False: 11.7M] ------------------ 492| 3.80M| next(ls); ------------------ | | 32| 3.80M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 3.80M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 3.80M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 3.80M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 3.80M, False: 2] | | | | ------------------ | | ------------------ ------------------ 493| 3.80M| if (check_next1(ls, '=')) return TK_LE; /* '<=' */ ------------------ | Branch (493:13): [True: 5.68k, False: 3.79M] ------------------ 494| 3.79M| else if (check_next1(ls, '<')) return TK_SHL; /* '<<' */ ------------------ | Branch (494:18): [True: 204k, False: 3.59M] ------------------ 495| 3.59M| else return '<'; 496| 3.80M| } 497| 39.7k| case '>': { ------------------ | Branch (497:7): [True: 39.7k, False: 15.5M] ------------------ 498| 39.7k| next(ls); ------------------ | | 32| 39.7k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 39.7k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 39.7k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 39.7k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 39.7k, False: 0] | | | | ------------------ | | ------------------ ------------------ 499| 39.7k| if (check_next1(ls, '=')) return TK_GE; /* '>=' */ ------------------ | Branch (499:13): [True: 504, False: 39.2k] ------------------ 500| 39.2k| else if (check_next1(ls, '>')) return TK_SHR; /* '>>' */ ------------------ | Branch (500:18): [True: 2.01k, False: 37.2k] ------------------ 501| 37.2k| else return '>'; 502| 39.7k| } 503| 2.90M| case '/': { ------------------ | Branch (503:7): [True: 2.90M, False: 12.6M] ------------------ 504| 2.90M| next(ls); ------------------ | | 32| 2.90M|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 2.90M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 2.90M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 2.90M|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 2.90M, False: 3] | | | | ------------------ | | ------------------ ------------------ 505| 2.90M| if (check_next1(ls, '/')) return TK_IDIV; /* '//' */ ------------------ | Branch (505:13): [True: 19.0k, False: 2.88M] ------------------ 506| 2.88M| else return '/'; 507| 2.90M| } 508| 109k| case '~': { ------------------ | Branch (508:7): [True: 109k, False: 15.4M] ------------------ 509| 109k| next(ls); ------------------ | | 32| 109k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 109k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 109k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 109k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 109k, False: 1] | | | | ------------------ | | ------------------ ------------------ 510| 109k| if (check_next1(ls, '=')) return TK_NE; /* '~=' */ ------------------ | Branch (510:13): [True: 2.45k, False: 106k] ------------------ 511| 106k| else return '~'; 512| 109k| } 513| 521| case ':': { ------------------ | Branch (513:7): [True: 521, False: 15.5M] ------------------ 514| 521| next(ls); ------------------ | | 32| 521|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 521|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 521|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 521|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 521, False: 0] | | | | ------------------ | | ------------------ ------------------ 515| 521| if (check_next1(ls, ':')) return TK_DBCOLON; /* '::' */ ------------------ | Branch (515:13): [True: 292, False: 229] ------------------ 516| 229| else return ':'; 517| 521| } 518| 107k| case '"': case '\'': { /* short literal strings */ ------------------ | Branch (518:7): [True: 105k, False: 15.4M] | Branch (518:17): [True: 1.29k, False: 15.5M] ------------------ 519| 107k| read_string(ls, ls->current, seminfo); 520| 107k| return TK_STRING; 521| 105k| } 522| 11.5k| case '.': { /* '.', '..', '...', or number */ ------------------ | Branch (522:7): [True: 11.5k, False: 15.5M] ------------------ 523| 11.5k| save_and_next(ls); ------------------ | | 51| 11.5k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 11.5k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 11.5k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 11.5k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 11.5k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 11.5k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 524| 11.5k| if (check_next1(ls, '.')) { ------------------ | Branch (524:13): [True: 6.74k, False: 4.77k] ------------------ 525| 6.74k| if (check_next1(ls, '.')) ------------------ | Branch (525:15): [True: 358, False: 6.38k] ------------------ 526| 358| return TK_DOTS; /* '...' */ 527| 6.38k| else return TK_CONCAT; /* '..' */ 528| 6.74k| } 529| 4.77k| else if (!lisdigit(ls->current)) return '.'; ------------------ | | 59| 4.77k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 4.77k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ | Branch (529:18): [True: 3.21k, False: 1.55k] ------------------ 530| 1.55k| else return read_numeral(ls, seminfo); 531| 11.5k| } 532| 159k| case '0': case '1': case '2': case '3': case '4': ------------------ | Branch (532:7): [True: 43.8k, False: 15.5M] | Branch (532:17): [True: 68.3k, False: 15.5M] | Branch (532:27): [True: 31.4k, False: 15.5M] | Branch (532:37): [True: 10.0k, False: 15.5M] | Branch (532:47): [True: 5.69k, False: 15.5M] ------------------ 533| 222k| case '5': case '6': case '7': case '8': case '9': { ------------------ | Branch (533:7): [True: 18.6k, False: 15.5M] | Branch (533:17): [True: 8.85k, False: 15.5M] | Branch (533:27): [True: 2.99k, False: 15.5M] | Branch (533:37): [True: 13.6k, False: 15.5M] | Branch (533:47): [True: 18.9k, False: 15.5M] ------------------ 534| 222k| return read_numeral(ls, seminfo); 535| 203k| } 536| 76| case EOZ: { ------------------ | | 16| 76|#define EOZ (-1) /* end of stream */ ------------------ | Branch (536:7): [True: 76, False: 15.5M] ------------------ 537| 76| return TK_EOS; 538| 203k| } 539| 7.89M| default: { ------------------ | Branch (539:7): [True: 7.89M, False: 7.67M] ------------------ 540| 7.89M| if (lislalpha(ls->current)) { /* identifier or reserved word? */ ------------------ | | 57| 7.89M|#define lislalpha(c) testprop(c, MASK(ALPHABIT)) | | ------------------ | | | | 52| 7.89M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 7.35M, False: 549k] | | | | ------------------ | | ------------------ ------------------ 541| 7.35M| TString *ts; 542| 12.1M| do { 543| 12.1M| save_and_next(ls); ------------------ | | 51| 12.1M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 12.1M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 12.1M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 12.1M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 12.1M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 12.1M, False: 34] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 544| 12.1M| } while (lislalnum(ls->current)); ------------------ | | 58| 12.1M|#define lislalnum(c) testprop(c, (MASK(ALPHABIT) | MASK(DIGITBIT))) | | ------------------ | | | | 52| 12.1M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 4.76M, False: 7.35M] | | | | ------------------ | | ------------------ ------------------ 545| 7.35M| ts = luaX_newstring(ls, luaZ_buffer(ls->buff), ------------------ | | 31| 7.35M|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 546| 7.35M| luaZ_bufflen(ls->buff)); ------------------ | | 33| 7.35M|#define luaZ_bufflen(buff) ((buff)->n) ------------------ 547| 7.35M| seminfo->ts = ts; 548| 7.35M| if (isreserved(ts)) /* reserved word? */ ------------------ | | 35| 7.35M|#define isreserved(s) ((s)->tt == LUA_VSHRSTR && (s)->extra > 0) | | ------------------ | | | | 360| 7.35M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | ------------------ | | | | | | 42| 14.7M|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (35:24): [True: 7.34M, False: 761] | | | Branch (35:50): [True: 212k, False: 7.13M] | | ------------------ ------------------ 549| 212k| return ts->extra - 1 + FIRST_RESERVED; ------------------ | | 20| 212k|#define FIRST_RESERVED (UCHAR_MAX + 1) ------------------ 550| 7.13M| else { 551| 7.13M| return TK_NAME; 552| 7.13M| } 553| 7.35M| } 554| 549k| else { /* single-char tokens ('+', '*', '%', '{', '}', ...) */ 555| 549k| int c = ls->current; 556| 549k| next(ls); ------------------ | | 32| 549k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 549k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 549k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 549k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 549k, False: 0] | | | | ------------------ | | ------------------ ------------------ 557| 549k| return c; 558| 549k| } 559| 7.89M| } 560| 15.5M| } 561| 15.5M| } 562| 15.3M|} llex.c:inclinenumber: 156| 524k|static void inclinenumber (LexState *ls) { 157| 524k| int old = ls->current; 158| 524k| lua_assert(currIsNewline(ls)); ------------------ | | 114| 524k|#define lua_assert(c) ((void)0) ------------------ 159| 524k| next(ls); /* skip '\n' or '\r' */ ------------------ | | 32| 524k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 524k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 524k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 524k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 524k, False: 2] | | | | ------------------ | | ------------------ ------------------ 160| 524k| if (currIsNewline(ls) && ls->current != old) ------------------ | | 36| 1.04M|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 118k, False: 405k] | | | Branch (36:51): [True: 232k, False: 172k] | | ------------------ ------------------ | Branch (160:28): [True: 35.8k, False: 315k] ------------------ 161| 35.8k| next(ls); /* skip '\n\r' or '\r\n' */ ------------------ | | 32| 35.8k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 35.8k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 35.8k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 35.8k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 35.8k, False: 0] | | | | ------------------ | | ------------------ ------------------ 162| 524k| if (++ls->linenumber >= MAX_INT) ------------------ | | 53| 524k|#define MAX_INT INT_MAX /* maximum value of an int */ ------------------ | Branch (162:7): [True: 0, False: 524k] ------------------ 163| 0| lexerror(ls, "chunk has too many lines", 0); 164| 524k|} llex.c:skip_sep: 265| 663k|static size_t skip_sep (LexState *ls) { 266| 663k| size_t count = 0; 267| 663k| int s = ls->current; 268| 663k| lua_assert(s == '[' || s == ']'); ------------------ | | 114| 663k|#define lua_assert(c) ((void)0) ------------------ 269| 663k| save_and_next(ls); ------------------ | | 51| 663k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 663k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 663k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 663k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 663k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 663k, False: 2] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 270| 735k| while (ls->current == '=') { ------------------ | Branch (270:10): [True: 72.4k, False: 663k] ------------------ 271| 72.4k| save_and_next(ls); ------------------ | | 51| 72.4k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 72.4k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 72.4k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 72.4k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 72.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 72.4k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 272| 72.4k| count++; 273| 72.4k| } 274| 663k| return (ls->current == s) ? count + 2 ------------------ | Branch (274:10): [True: 621k, False: 41.9k] ------------------ 275| 663k| : (count == 0) ? 1 ------------------ | Branch (275:12): [True: 40.5k, False: 1.34k] ------------------ 276| 41.9k| : 0; 277| 663k|} llex.c:read_long_string: 280| 88.4k|static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) { 281| 88.4k| int line = ls->linenumber; /* initial line (for error message) */ 282| 88.4k| save_and_next(ls); /* skip 2nd '[' */ ------------------ | | 51| 88.4k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 88.4k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 88.4k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 88.4k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 88.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 88.4k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 283| 88.4k| if (currIsNewline(ls)) /* string starts with a newline? */ ------------------ | | 36| 88.4k|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 77.4k, False: 11.0k] | | | Branch (36:51): [True: 7.48k, False: 3.58k] | | ------------------ ------------------ 284| 84.8k| inclinenumber(ls); /* skip it */ 285| 4.67M| for (;;) { 286| 4.67M| switch (ls->current) { 287| 9| case EOZ: { /* error */ ------------------ | | 16| 9|#define EOZ (-1) /* end of stream */ ------------------ | Branch (287:7): [True: 9, False: 4.67M] ------------------ 288| 9| const char *what = (seminfo ? "string" : "comment"); ------------------ | Branch (288:29): [True: 9, False: 0] ------------------ 289| 9| const char *msg = luaO_pushfstring(ls->L, 290| 9| "unfinished long %s (starting at line %d)", what, line); 291| 9| lexerror(ls, msg, TK_EOS); 292| 0| break; /* to avoid warnings */ 293| 0| } 294| 562k| case ']': { ------------------ | Branch (294:7): [True: 562k, False: 4.10M] ------------------ 295| 562k| if (skip_sep(ls) == sep) { ------------------ | Branch (295:13): [True: 88.4k, False: 473k] ------------------ 296| 88.4k| save_and_next(ls); /* skip 2nd ']' */ ------------------ | | 51| 88.4k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 88.4k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 88.4k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 88.4k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 88.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 88.4k, False: 2] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 297| 88.4k| goto endloop; 298| 88.4k| } 299| 473k| break; 300| 562k| } 301| 473k| case '\n': case '\r': { ------------------ | Branch (301:7): [True: 100k, False: 4.57M] | Branch (301:18): [True: 225k, False: 4.44M] ------------------ 302| 325k| save(ls, '\n'); 303| 325k| inclinenumber(ls); 304| 325k| if (!seminfo) luaZ_resetbuffer(ls->buff); /* avoid wasting space */ ------------------ | | 36| 401|#define luaZ_resetbuffer(buff) ((buff)->n = 0) ------------------ | Branch (304:13): [True: 401, False: 325k] ------------------ 305| 325k| break; 306| 100k| } 307| 3.78M| default: { ------------------ | Branch (307:7): [True: 3.78M, False: 887k] ------------------ 308| 3.78M| if (seminfo) save_and_next(ls); ------------------ | | 51| 3.33M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 3.33M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 3.33M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 3.33M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 3.33M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 3.33M, False: 5] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (308:13): [True: 3.33M, False: 448k] ------------------ 309| 448k| else next(ls); ------------------ | | 32| 448k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 448k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 448k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 448k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 448k, False: 0] | | | | ------------------ | | ------------------ ------------------ 310| 3.78M| } 311| 4.67M| } 312| 4.67M| } endloop: 313| 88.4k| if (seminfo) ------------------ | Branch (313:7): [True: 88.4k, False: 38] ------------------ 314| 88.4k| seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep, ------------------ | | 31| 88.4k|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 315| 88.4k| luaZ_bufflen(ls->buff) - 2 * sep); ------------------ | | 33| 88.4k|#define luaZ_bufflen(buff) ((buff)->n) ------------------ 316| 88.4k|} llex.c:check_next1: 191| 10.7M|static int check_next1 (LexState *ls, int c) { 192| 10.7M| if (ls->current == c) { ------------------ | Branch (192:7): [True: 243k, False: 10.4M] ------------------ 193| 243k| next(ls); ------------------ | | 32| 243k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 243k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 243k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 243k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 243k, False: 0] | | | | ------------------ | | ------------------ ------------------ 194| 243k| return 1; 195| 243k| } 196| 10.4M| else return 0; 197| 10.7M|} llex.c:read_string: 382| 107k|static void read_string (LexState *ls, int del, SemInfo *seminfo) { 383| 107k| save_and_next(ls); /* keep delimiter (for error messages) */ ------------------ | | 51| 107k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 107k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 107k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 107k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 107k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 107k, False: 1] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 384| 6.45M| while (ls->current != del) { ------------------ | Branch (384:10): [True: 6.34M, False: 107k] ------------------ 385| 6.34M| switch (ls->current) { 386| 7| case EOZ: ------------------ | | 16| 7|#define EOZ (-1) /* end of stream */ ------------------ | Branch (386:7): [True: 7, False: 6.34M] ------------------ 387| 7| lexerror(ls, "unfinished string", TK_EOS); 388| 0| break; /* to avoid warnings */ 389| 4| case '\n': ------------------ | Branch (389:7): [True: 4, False: 6.34M] ------------------ 390| 6| case '\r': ------------------ | Branch (390:7): [True: 2, False: 6.34M] ------------------ 391| 6| lexerror(ls, "unfinished string", TK_STRING); 392| 0| break; /* to avoid warnings */ 393| 17.2k| case '\\': { /* escape sequences */ ------------------ | Branch (393:7): [True: 17.2k, False: 6.33M] ------------------ 394| 17.2k| int c; /* final character to be saved */ 395| 17.2k| save_and_next(ls); /* keep '\\' for error messages */ ------------------ | | 51| 17.2k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 17.2k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 17.2k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 17.2k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 17.2k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 17.2k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 396| 17.2k| switch (ls->current) { 397| 52| case 'a': c = '\a'; goto read_save; ------------------ | Branch (397:11): [True: 52, False: 17.2k] ------------------ 398| 835| case 'b': c = '\b'; goto read_save; ------------------ | Branch (398:11): [True: 835, False: 16.4k] ------------------ 399| 2.81k| case 'f': c = '\f'; goto read_save; ------------------ | Branch (399:11): [True: 2.81k, False: 14.4k] ------------------ 400| 2| case 'n': c = '\n'; goto read_save; ------------------ | Branch (400:11): [True: 2, False: 17.2k] ------------------ 401| 1.25k| case 'r': c = '\r'; goto read_save; ------------------ | Branch (401:11): [True: 1.25k, False: 16.0k] ------------------ 402| 1.02k| case 't': c = '\t'; goto read_save; ------------------ | Branch (402:11): [True: 1.02k, False: 16.2k] ------------------ 403| 6| case 'v': c = '\v'; goto read_save; ------------------ | Branch (403:11): [True: 6, False: 17.2k] ------------------ 404| 680| case 'x': c = readhexaesc(ls); goto read_save; ------------------ | Branch (404:11): [True: 680, False: 16.5k] ------------------ 405| 3.24k| case 'u': utf8esc(ls); goto no_save; ------------------ | Branch (405:11): [True: 3.24k, False: 14.0k] ------------------ 406| 31| case '\n': case '\r': ------------------ | Branch (406:11): [True: 31, False: 17.2k] | Branch (406:22): [True: 0, False: 17.2k] ------------------ 407| 31| inclinenumber(ls); c = '\n'; goto only_save; 408| 1.16k| case '\\': case '\"': case '\'': ------------------ | Branch (408:11): [True: 547, False: 16.7k] | Branch (408:22): [True: 612, False: 16.6k] | Branch (408:33): [True: 9, False: 17.2k] ------------------ 409| 1.16k| c = ls->current; goto read_save; 410| 0| case EOZ: goto no_save; /* will raise an error next loop */ ------------------ | | 16| 0|#define EOZ (-1) /* end of stream */ ------------------ | Branch (410:11): [True: 0, False: 17.2k] ------------------ 411| 5| case 'z': { /* zap following span of spaces */ ------------------ | Branch (411:11): [True: 5, False: 17.2k] ------------------ 412| 5| luaZ_buffremove(ls->buff, 1); /* remove '\\' */ ------------------ | | 35| 5|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 413| 5| next(ls); /* skip the 'z' */ ------------------ | | 32| 5|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 5|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 5|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 5|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 5, False: 0] | | | | ------------------ | | ------------------ ------------------ 414| 5| while (lisspace(ls->current)) { 415| 0| if (currIsNewline(ls)) inclinenumber(ls); ------------------ | | 36| 0|#define currIsNewline(ls) (ls->current == '\n' || ls->current == '\r') | | ------------------ | | | Branch (36:28): [True: 0, False: 0] | | | Branch (36:51): [True: 0, False: 0] | | ------------------ ------------------ 416| 0| else next(ls); ------------------ | | 32| 0|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 0|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 0|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 417| 0| } 418| 5| goto no_save; 419| 1.15k| } 420| 6.14k| default: { ------------------ | Branch (420:11): [True: 6.14k, False: 11.1k] ------------------ 421| 6.14k| esccheck(ls, lisdigit(ls->current), "invalid escape sequence"); ------------------ | | 59| 6.14k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 6.14k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ 422| 6.14k| c = readdecesc(ls); /* digital escape '\ddd' */ 423| 6.14k| goto only_save; 424| 1.15k| } 425| 17.2k| } 426| 7.84k| read_save: 427| 7.84k| next(ls); ------------------ | | 32| 7.84k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 7.84k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 7.84k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 7.84k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 7.84k, False: 0] | | | | ------------------ | | ------------------ ------------------ 428| | /* go through */ 429| 14.0k| only_save: 430| 14.0k| luaZ_buffremove(ls->buff, 1); /* remove '\\' */ ------------------ | | 35| 14.0k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 431| 14.0k| save(ls, c); 432| | /* go through */ 433| 17.2k| no_save: break; 434| 14.0k| } 435| 6.33M| default: ------------------ | Branch (435:7): [True: 6.33M, False: 17.2k] ------------------ 436| 6.33M| save_and_next(ls); ------------------ | | 51| 6.33M|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 6.33M|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 6.33M|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 6.33M|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 6.33M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 6.33M, False: 6] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 437| 6.34M| } 438| 6.34M| } 439| 107k| save_and_next(ls); /* skip delimiter */ ------------------ | | 51| 107k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 107k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 107k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 107k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 107k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 107k, False: 20] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 440| 107k| seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + 1, ------------------ | | 31| 107k|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ 441| 107k| luaZ_bufflen(ls->buff) - 2); ------------------ | | 33| 107k|#define luaZ_bufflen(buff) ((buff)->n) ------------------ 442| 107k|} llex.c:readhexaesc: 335| 680|static int readhexaesc (LexState *ls) { 336| 680| int r = gethexa(ls); 337| 680| r = (r << 4) + gethexa(ls); 338| 680| luaZ_buffremove(ls->buff, 2); /* remove saved chars from buffer */ ------------------ | | 35| 680|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 339| 680| return r; 340| 680|} llex.c:gethexa: 328| 4.59k|static int gethexa (LexState *ls) { 329| 4.59k| save_and_next(ls); ------------------ | | 51| 4.59k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 4.59k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 4.59k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 4.59k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 4.59k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 4.59k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 330| 4.59k| esccheck (ls, lisxdigit(ls->current), "hexadecimal digit expected"); ------------------ | | 62| 4.59k|#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) | | ------------------ | | | | 52| 4.59k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ 331| 4.59k| return luaO_hexavalue(ls->current); 332| 4.59k|} llex.c:utf8esc: 361| 3.24k|static void utf8esc (LexState *ls) { 362| 3.24k| char buff[UTF8BUFFSZ]; 363| 3.24k| int n = luaO_utf8esc(buff, readutf8esc(ls)); 364| 19.6k| for (; n > 0; n--) /* add 'buff' to string */ ------------------ | Branch (364:10): [True: 16.4k, False: 3.24k] ------------------ 365| 16.4k| save(ls, buff[UTF8BUFFSZ - n]); ------------------ | | 797| 16.4k|#define UTF8BUFFSZ 8 ------------------ 366| 3.24k|} llex.c:readutf8esc: 343| 3.24k|static unsigned long readutf8esc (LexState *ls) { 344| 3.24k| unsigned long r; 345| 3.24k| int i = 4; /* chars to be removed: '\', 'u', '{', and first digit */ 346| 3.24k| save_and_next(ls); /* skip 'u' */ ------------------ | | 51| 3.24k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 3.24k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 3.24k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 3.24k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 3.24k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 3.24k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 347| 3.24k| esccheck(ls, ls->current == '{', "missing '{'"); 348| 3.24k| r = gethexa(ls); /* must have at least one digit */ 349| 61.4k| while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) { ------------------ | | 138| 61.4k|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 122k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 61.3k, False: 8] | | | | ------------------ | | ------------------ ------------------ while (cast_void(save_and_next(ls)), lisxdigit(ls->current)) { ------------------ | | 62| 61.4k|#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) | | ------------------ | | | | 52| 61.4k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | ------------------ ------------------ | Branch (349:10): [True: 58.1k, False: 3.24k] ------------------ 350| 58.1k| i++; 351| 58.1k| esccheck(ls, r <= (0x7FFFFFFFu >> 4), "UTF-8 value too large"); 352| 58.1k| r = (r << 4) + luaO_hexavalue(ls->current); 353| 58.1k| } 354| 3.24k| esccheck(ls, ls->current == '}', "missing '}'"); 355| 3.24k| next(ls); /* skip '}' */ ------------------ | | 32| 3.24k|#define next(ls) (ls->current = zgetc(ls->z)) | | ------------------ | | | | 20| 3.24k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | ------------------ | | | | | | 144| 3.22k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | ------------------ | | | | | | | | 136| 3.22k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (20:20): [True: 3.22k, False: 14] | | | | ------------------ | | ------------------ ------------------ 356| 3.24k| luaZ_buffremove(ls->buff, i); /* remove saved chars from buffer */ ------------------ | | 35| 3.24k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 357| 3.24k| return r; 358| 3.24k|} llex.c:esccheck: 319| 81.5k|static void esccheck (LexState *ls, int c, const char *msg) { 320| 81.5k| if (!c) { ------------------ | Branch (320:7): [True: 22, False: 81.5k] ------------------ 321| 22| if (ls->current != EOZ) ------------------ | | 16| 22|#define EOZ (-1) /* end of stream */ ------------------ | Branch (321:9): [True: 22, False: 0] ------------------ 322| 22| save_and_next(ls); /* add current to buffer for error message */ ------------------ | | 51| 22|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 22|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 22|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 22|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 22|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 22, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 323| 22| lexerror(ls, msg, TK_STRING); 324| 22| } 325| 81.5k|} llex.c:readdecesc: 369| 6.14k|static int readdecesc (LexState *ls) { 370| 6.14k| int i; 371| 6.14k| int r = 0; /* result accumulator */ 372| 21.4k| for (i = 0; i < 3 && lisdigit(ls->current); i++) { /* read up to 3 digits */ ------------------ | | 59| 16.9k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 16.9k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 15.2k, False: 1.64k] | | | | ------------------ | | ------------------ ------------------ | Branch (372:15): [True: 16.9k, False: 4.50k] ------------------ 373| 15.2k| r = 10*r + ls->current - '0'; 374| 15.2k| save_and_next(ls); ------------------ | | 51| 15.2k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 15.2k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 15.2k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 15.2k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 15.2k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 15.2k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 375| 15.2k| } 376| 6.14k| esccheck(ls, r <= UCHAR_MAX, "decimal escape too large"); 377| 6.14k| luaZ_buffremove(ls->buff, i); /* remove read digits from buffer */ ------------------ | | 35| 6.14k|#define luaZ_buffremove(buff,i) ((buff)->n -= (i)) ------------------ 378| 6.14k| return r; 379| 6.14k|} llex.c:read_numeral: 227| 224k|static int read_numeral (LexState *ls, SemInfo *seminfo) { 228| 224k| TValue obj; 229| 224k| const char *expo = "Ee"; 230| 224k| int first = ls->current; 231| 224k| lua_assert(lisdigit(ls->current)); ------------------ | | 114| 224k|#define lua_assert(c) ((void)0) ------------------ 232| 224k| save_and_next(ls); ------------------ | | 51| 224k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 224k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 224k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 224k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 224k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 224k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 233| 224k| if (first == '0' && check_next2(ls, "xX")) /* hexadecimal? */ ------------------ | Branch (233:7): [True: 44.6k, False: 179k] | Branch (233:23): [True: 0, False: 44.6k] ------------------ 234| 0| expo = "Pp"; 235| 878k| for (;;) { 236| 878k| if (check_next2(ls, expo)) /* exponent mark? */ ------------------ | Branch (236:9): [True: 45.2k, False: 833k] ------------------ 237| 45.2k| check_next2(ls, "-+"); /* optional exponent sign */ 238| 833k| else if (lisxdigit(ls->current) || ls->current == '.') /* '%x|%.' */ ------------------ | | 62| 833k|#define lisxdigit(c) testprop(c, MASK(XDIGITBIT)) | | ------------------ | | | | 52| 1.66M|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 592k, False: 240k] | | | | ------------------ | | ------------------ ------------------ | Branch (238:40): [True: 16.6k, False: 224k] ------------------ 239| 609k| save_and_next(ls); ------------------ | | 51| 609k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 609k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 609k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 609k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 609k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 609k, False: 3] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 240| 224k| else break; 241| 878k| } 242| 224k| if (lislalpha(ls->current)) /* is numeral touching a letter? */ ------------------ | | 57| 224k|#define lislalpha(c) testprop(c, MASK(ALPHABIT)) | | ------------------ | | | | 52| 224k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 9, False: 224k] | | | | ------------------ | | ------------------ ------------------ 243| 9| save_and_next(ls); /* force an error */ ------------------ | | 51| 9|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 9|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 9|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 9|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 9|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 9, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 244| 224k| save(ls, '\0'); 245| 224k| if (luaO_str2num(luaZ_buffer(ls->buff), &obj) == 0) /* format error? */ ------------------ | | 31| 224k|#define luaZ_buffer(buff) ((buff)->buffer) ------------------ | Branch (245:7): [True: 11, False: 224k] ------------------ 246| 11| lexerror(ls, "malformed number", TK_FLT); 247| 224k| if (ttisinteger(&obj)) { ------------------ | | 328| 224k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 224k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 224k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 201k, False: 22.9k] | | | | ------------------ | | ------------------ ------------------ 248| 201k| seminfo->i = ivalue(&obj); ------------------ | | 333| 201k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 201k|#define check_exp(c,e) (e) | | ------------------ ------------------ 249| 201k| return TK_INT; 250| 201k| } 251| 22.9k| else { 252| 22.9k| lua_assert(ttisfloat(&obj)); ------------------ | | 114| 22.9k|#define lua_assert(c) ((void)0) ------------------ 253| 22.9k| seminfo->r = fltvalue(&obj); ------------------ | | 332| 22.9k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 22.9k|#define check_exp(c,e) (e) | | ------------------ ------------------ 254| 22.9k| return TK_FLT; 255| 22.9k| } 256| 224k|} llex.c:check_next2: 204| 968k|static int check_next2 (LexState *ls, const char *set) { 205| 968k| lua_assert(set[2] == '\0'); ------------------ | | 114| 968k|#define lua_assert(c) ((void)0) ------------------ 206| 968k| if (ls->current == set[0] || ls->current == set[1]) { ------------------ | Branch (206:7): [True: 42.8k, False: 925k] | Branch (206:32): [True: 2.34k, False: 923k] ------------------ 207| 45.2k| save_and_next(ls); ------------------ | | 51| 45.2k|#define save_and_next(ls) (save(ls, ls->current), next(ls)) | | ------------------ | | | | 32| 45.2k|#define next(ls) (ls->current = zgetc(ls->z)) | | | | ------------------ | | | | | | 20| 45.2k|#define zgetc(z) (((z)->n--)>0 ? cast_uchar(*(z)->p++) : luaZ_fill(z)) | | | | | | ------------------ | | | | | | | | 144| 45.2k|#define cast_uchar(i) cast(unsigned char, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 45.2k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (20:20): [True: 45.2k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 208| 45.2k| return 1; 209| 45.2k| } 210| 923k| else return 0; 211| 968k|} luaM_growaux_: 98| 73.4M| int size_elems, int limit, const char *what) { 99| 73.4M| void *newblock; 100| 73.4M| int size = *psize; 101| 73.4M| if (nelems + 1 <= size) /* does one extra element still fit? */ ------------------ | Branch (101:7): [True: 73.4M, False: 38.3k] ------------------ 102| 73.4M| return block; /* nothing to be done */ 103| 38.3k| if (size >= limit / 2) { /* cannot double it? */ ------------------ | Branch (103:7): [True: 0, False: 38.3k] ------------------ 104| 0| if (l_unlikely(size >= limit)) /* cannot grow even a little? */ ------------------ | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 105| 0| luaG_runerror(L, "too many %s (limit is %d)", what, limit); 106| 0| size = limit; /* still have at least one free place */ 107| 0| } 108| 38.3k| else { 109| 38.3k| size *= 2; 110| 38.3k| if (size < MINSIZEARRAY) ------------------ | | 94| 38.3k|#define MINSIZEARRAY 4 ------------------ | Branch (110:9): [True: 17.0k, False: 21.2k] ------------------ 111| 17.0k| size = MINSIZEARRAY; /* minimum size */ ------------------ | | 94| 17.0k|#define MINSIZEARRAY 4 ------------------ 112| 38.3k| } 113| 38.3k| lua_assert(nelems + 1 <= size && size <= limit); ------------------ | | 114| 38.3k|#define lua_assert(c) ((void)0) ------------------ 114| | /* 'limit' ensures that multiplication will not overflow */ 115| 38.3k| newblock = luaM_saferealloc_(L, block, cast_sizet(*psize) * size_elems, ------------------ | | 147| 38.3k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 38.3k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 116| 38.3k| cast_sizet(size) * size_elems); ------------------ | | 147| 38.3k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 38.3k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 117| 38.3k| *psize = size; /* update only when everything else is OK */ 118| 38.3k| return newblock; 119| 38.3k|} luaM_shrinkvector_: 129| 27.5k| int final_n, int size_elem) { 130| 27.5k| void *newblock; 131| 27.5k| size_t oldsize = cast_sizet((*size) * size_elem); ------------------ | | 147| 27.5k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 27.5k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 132| 27.5k| size_t newsize = cast_sizet(final_n * size_elem); ------------------ | | 147| 27.5k|#define cast_sizet(i) cast(size_t, (i)) | | ------------------ | | | | 136| 27.5k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 133| 27.5k| lua_assert(newsize <= oldsize); ------------------ | | 114| 27.5k|#define lua_assert(c) ((void)0) ------------------ 134| 27.5k| newblock = luaM_saferealloc_(L, block, oldsize, newsize); 135| 27.5k| *size = final_n; 136| 27.5k| return newblock; 137| 27.5k|} luaM_free_: 150| 570k|void luaM_free_ (lua_State *L, void *block, size_t osize) { 151| 570k| global_State *g = G(L); ------------------ | | 335| 570k|#define G(L) (L->l_G) ------------------ 152| 570k| lua_assert((osize == 0) == (block == NULL)); ------------------ | | 114| 570k|#define lua_assert(c) ((void)0) ------------------ 153| 570k| callfrealloc(g, block, osize, 0); ------------------ | | 47| 570k|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) ------------------ 154| 570k| g->GCdebt -= osize; 155| 570k|} luaM_realloc_: 176| 189k|void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) { 177| 189k| void *newblock; 178| 189k| global_State *g = G(L); ------------------ | | 335| 189k|#define G(L) (L->l_G) ------------------ 179| 189k| lua_assert((osize == 0) == (block == NULL)); ------------------ | | 114| 189k|#define lua_assert(c) ((void)0) ------------------ 180| 189k| newblock = firsttry(g, block, osize, nsize); ------------------ | | 76| 189k|#define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns) | | ------------------ | | | | 47| 189k|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) | | ------------------ ------------------ 181| 189k| if (l_unlikely(newblock == NULL && nsize > 0)) { ------------------ | | 688| 189k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 205k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 189k] | | | | | Branch (676:46): [True: 15.7k, False: 173k] | | | | | Branch (676:46): [True: 0, False: 15.7k] | | | | ------------------ | | ------------------ ------------------ 182| 0| newblock = tryagain(L, block, osize, nsize); 183| 0| if (newblock == NULL) /* still no memory? */ ------------------ | Branch (183:9): [True: 0, False: 0] ------------------ 184| 0| return NULL; /* do not update 'GCdebt' */ 185| 0| } 186| 189k| lua_assert((nsize == 0) == (newblock == NULL)); ------------------ | | 114| 189k|#define lua_assert(c) ((void)0) ------------------ 187| 189k| g->GCdebt = (g->GCdebt + nsize) - osize; 188| 189k| return newblock; 189| 189k|} luaM_saferealloc_: 193| 67.4k| size_t nsize) { 194| 67.4k| void *newblock = luaM_realloc_(L, block, osize, nsize); 195| 67.4k| if (l_unlikely(newblock == NULL && nsize > 0)) /* allocation failed? */ ------------------ | | 688| 67.4k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 81.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 67.4k] | | | | | Branch (676:46): [True: 14.2k, False: 53.1k] | | | | | Branch (676:46): [True: 0, False: 14.2k] | | | | ------------------ | | ------------------ ------------------ 196| 0| luaM_error(L); ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 53| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 197| 67.4k| return newblock; 198| 67.4k|} luaM_malloc_: 201| 418k|void *luaM_malloc_ (lua_State *L, size_t size, int tag) { 202| 418k| if (size == 0) ------------------ | Branch (202:7): [True: 0, False: 418k] ------------------ 203| 0| return NULL; /* that's all */ 204| 418k| else { 205| 418k| global_State *g = G(L); ------------------ | | 335| 418k|#define G(L) (L->l_G) ------------------ 206| 418k| void *newblock = firsttry(g, NULL, tag, size); ------------------ | | 76| 418k|#define firsttry(g,block,os,ns) callfrealloc(g, block, os, ns) | | ------------------ | | | | 47| 418k|#define callfrealloc(g,block,os,ns) ((*g->frealloc)(g->ud, block, os, ns)) | | ------------------ ------------------ 207| 418k| if (l_unlikely(newblock == NULL)) { ------------------ | | 688| 418k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 418k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 418k] | | | | ------------------ | | ------------------ ------------------ 208| 0| newblock = tryagain(L, NULL, tag, size); 209| 0| if (newblock == NULL) ------------------ | Branch (209:11): [True: 0, False: 0] ------------------ 210| 0| luaM_error(L); ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 53| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 211| 0| } 212| 418k| g->GCdebt += size; 213| 418k| return newblock; 214| 418k| } 215| 418k|} luaO_ceillog2: 35| 169k|int luaO_ceillog2 (unsigned int x) { 36| 169k| static const lu_byte log_2[256] = { /* log_2[i] = ceil(log2(i - 1)) */ 37| 169k| 0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5, 38| 169k| 6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6, 39| 169k| 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 40| 169k| 7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7, 41| 169k| 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 42| 169k| 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 43| 169k| 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8, 44| 169k| 8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8 45| 169k| }; 46| 169k| int l = 0; 47| 169k| x--; 48| 490k| while (x >= 256) { l += 8; x >>= 8; } ------------------ | Branch (48:10): [True: 321k, False: 169k] ------------------ 49| 169k| return l + log_2[x]; 50| 169k|} luaO_rawarith: 90| 113k| TValue *res) { 91| 113k| switch (op) { 92| 2.30k| case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 222| 1.12k|#define LUA_OPBAND 7 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 223| 1.14k|#define LUA_OPBOR 8 ------------------ case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR: ------------------ | | 224| 2.30k|#define LUA_OPBXOR 9 ------------------ | Branch (92:5): [True: 1.12k, False: 112k] | Branch (92:22): [True: 21, False: 113k] | Branch (92:38): [True: 1.15k, False: 112k] ------------------ 93| 2.94k| case LUA_OPSHL: case LUA_OPSHR: ------------------ | | 225| 2.47k|#define LUA_OPSHL 10 ------------------ case LUA_OPSHL: case LUA_OPSHR: ------------------ | | 226| 2.94k|#define LUA_OPSHR 11 ------------------ | Branch (93:5): [True: 170, False: 113k] | Branch (93:21): [True: 473, False: 113k] ------------------ 94| 30.9k| case LUA_OPBNOT: { /* operate only on integers */ ------------------ | | 228| 30.9k|#define LUA_OPBNOT 13 ------------------ | Branch (94:5): [True: 27.9k, False: 85.7k] ------------------ 95| 30.9k| lua_Integer i1; lua_Integer i2; 96| 30.9k| if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) { ------------------ | | 69| 61.8k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 687| 30.9k|#define l_likely(x) luai_likely(x) | | | | ------------------ | | | | | | 675| 30.9k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | ------------------ | | | | | | | Branch (675:25): [True: 26.6k, False: 4.22k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 333| 26.6k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 26.6k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (69:3): [True: 30.9k, False: 0] | | ------------------ | | 70| 61.8k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | ------------------ | | | | 36| 4.22k|#define LUA_FLOORN2I F2Ieq | | ------------------ ------------------ if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) { ------------------ | | 69| 30.9k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 687| 30.9k|#define l_likely(x) luai_likely(x) | | | | ------------------ | | | | | | 675| 30.9k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | ------------------ | | | | | | | Branch (675:25): [True: 30.4k, False: 446] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 333| 30.4k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 30.4k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (69:3): [True: 30.9k, False: 0] | | ------------------ | | 70| 30.9k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | ------------------ | | | | 36| 446|#define LUA_FLOORN2I F2Ieq | | ------------------ ------------------ 97| 30.9k| setivalue(res, intarith(L, op, i1, i2)); ------------------ | | 345| 30.9k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 30.9k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 30.9k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 98| 30.9k| return 1; 99| 30.9k| } 100| 0| else return 0; /* fail */ 101| 30.9k| } 102| 59.2k| case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */ ------------------ | | 220| 175|#define LUA_OPDIV 5 ------------------ case LUA_OPDIV: case LUA_OPPOW: { /* operate only on floats */ ------------------ | | 219| 59.2k|#define LUA_OPPOW 4 ------------------ | Branch (102:5): [True: 175, False: 113k] | Branch (102:21): [True: 59.0k, False: 54.6k] ------------------ 103| 59.2k| lua_Number n1; lua_Number n2; 104| 59.2k| if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 118k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 59.2k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 59.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 59.2k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 9.53k, False: 49.7k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 9.53k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 9.53k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 59.2k, False: 0] | | ------------------ | | 58| 118k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 49.7k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 49.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 49.7k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 49.7k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 140| 49.7k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 49.7k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 59.2k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 59.2k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 59.2k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 59.2k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 14.4k, False: 44.7k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 14.4k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 14.4k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 59.2k, False: 0] | | ------------------ | | 58| 59.2k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 44.7k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 44.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 44.7k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 44.7k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 140| 44.7k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 44.7k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 105| 59.2k| setfltvalue(res, numarith(L, op, n1, n2)); ------------------ | | 339| 59.2k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 59.2k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 59.2k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 106| 59.2k| return 1; 107| 59.2k| } 108| 0| else return 0; /* fail */ 109| 59.2k| } 110| 23.5k| default: { /* other operations */ ------------------ | Branch (110:5): [True: 23.5k, False: 90.1k] ------------------ 111| 23.5k| lua_Number n1; lua_Number n2; 112| 23.5k| if (ttisinteger(p1) && ttisinteger(p2)) { ------------------ | | 328| 23.5k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 47.0k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 23.5k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 16.9k, False: 6.59k] | | | | ------------------ | | ------------------ ------------------ if (ttisinteger(p1) && ttisinteger(p2)) { ------------------ | | 328| 16.9k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 16.9k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 16.9k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 12.8k, False: 4.11k] | | | | ------------------ | | ------------------ ------------------ 113| 12.8k| setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2))); ------------------ | | 345| 12.8k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 12.8k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 12.8k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 114| 12.8k| return 1; 115| 12.8k| } 116| 10.7k| else if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 21.4k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 10.7k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 10.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 10.7k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 6.59k, False: 4.11k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 6.59k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 6.59k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 10.7k, False: 0] | | ------------------ | | 58| 21.4k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 4.11k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 4.11k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 4.11k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 4.11k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 140| 4.11k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 4.11k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ else if (tonumberns(p1, n1) && tonumberns(p2, n2)) { ------------------ | | 57| 10.7k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 10.7k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 10.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 10.7k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 5.77k, False: 4.93k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 5.77k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 5.77k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 10.7k, False: 0] | | ------------------ | | 58| 10.7k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 4.93k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 4.93k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 4.93k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 4.93k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 140| 4.93k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 4.93k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 117| 10.7k| setfltvalue(res, numarith(L, op, n1, n2)); ------------------ | | 339| 10.7k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 10.7k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 10.7k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 118| 10.7k| return 1; 119| 10.7k| } 120| 0| else return 0; /* fail */ 121| 23.5k| } 122| 113k| } 123| 113k|} luaO_hexavalue: 135| 62.7k|int luaO_hexavalue (int c) { 136| 62.7k| if (lisdigit(c)) return c - '0'; ------------------ | | 59| 62.7k|#define lisdigit(c) testprop(c, MASK(DIGITBIT)) | | ------------------ | | | | 52| 62.7k|#define testprop(c,p) (luai_ctype_[(c)+1] & (p)) | | | | ------------------ | | | | | Branch (52:23): [True: 58.1k, False: 4.59k] | | | | ------------------ | | ------------------ ------------------ 137| 4.59k| else return (ltolower(c) - 'a') + 10; ------------------ | | 72| 4.59k| check_exp(('A' <= (c) && (c) <= 'Z') || (c) == ((c) | ('A' ^ 'a')), \ | | ------------------ | | | | 115| 4.59k|#define check_exp(c,e) (e) | | ------------------ | | 73| 4.59k| (c) | ('A' ^ 'a')) ------------------ 138| 62.7k|} luaO_str2num: 308| 224k|size_t luaO_str2num (const char *s, TValue *o) { 309| 224k| lua_Integer i; lua_Number n; 310| 224k| const char *e; 311| 224k| if ((e = l_str2int(s, &i)) != NULL) { /* try as an integer */ ------------------ | Branch (311:7): [True: 201k, False: 22.9k] ------------------ 312| 201k| setivalue(o, i); ------------------ | | 345| 201k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 201k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 201k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 313| 201k| } 314| 22.9k| else if ((e = l_str2d(s, &n)) != NULL) { /* else try as a float */ ------------------ | Branch (314:12): [True: 22.9k, False: 18] ------------------ 315| 22.9k| setfltvalue(o, n); ------------------ | | 339| 22.9k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 22.9k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 22.9k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 316| 22.9k| } 317| 18| else 318| 18| return 0; /* conversion failed */ 319| 224k| return (e - s) + 1; /* success; return string size */ 320| 224k|} luaO_utf8esc: 323| 3.22k|int luaO_utf8esc (char *buff, unsigned long x) { 324| 3.22k| int n = 1; /* number of bytes put in buffer (backwards) */ 325| 3.22k| lua_assert(x <= 0x7FFFFFFFu); ------------------ | | 114| 3.22k|#define lua_assert(c) ((void)0) ------------------ 326| 3.22k| if (x < 0x80) /* ascii? */ ------------------ | Branch (326:7): [True: 30, False: 3.19k] ------------------ 327| 30| buff[UTF8BUFFSZ - 1] = cast_char(x); ------------------ | | 797| 30|#define UTF8BUFFSZ 8 ------------------ buff[UTF8BUFFSZ - 1] = cast_char(x); ------------------ | | 145| 30|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 136| 30|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 328| 3.19k| else { /* need continuation bytes */ 329| 3.19k| unsigned int mfb = 0x3f; /* maximum that fits in first byte */ 330| 13.2k| do { /* add continuation bytes */ 331| 13.2k| buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f)); ------------------ | | 797| 13.2k|#define UTF8BUFFSZ 8 ------------------ buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f)); ------------------ | | 145| 13.2k|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 136| 13.2k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 332| 13.2k| x >>= 6; /* remove added bits */ 333| 13.2k| mfb >>= 1; /* now there is one less bit available in first byte */ 334| 13.2k| } while (x > mfb); /* still needs continuation byte? */ ------------------ | Branch (334:14): [True: 10.0k, False: 3.19k] ------------------ 335| 3.19k| buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x); /* add first byte */ ------------------ | | 797| 3.19k|#define UTF8BUFFSZ 8 ------------------ buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x); /* add first byte */ ------------------ | | 145| 3.19k|#define cast_char(i) cast(char, (i)) | | ------------------ | | | | 136| 3.19k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 336| 3.19k| } 337| 3.22k| return n; 338| 3.22k|} luaO_tostring: 374| 147k|void luaO_tostring (lua_State *L, TValue *obj) { 375| 147k| char buff[MAXNUMBER2STR]; 376| 147k| int len = tostringbuff(obj, buff); 377| 147k| setsvalue(L, obj, luaS_newlstr(L, buff, len)); ------------------ | | 372| 147k| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 147k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 147k|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 147k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 147k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 147k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 147k| checkliveness(L,io); } | | ------------------ | | | | 107| 147k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 147k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 147k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 378| 147k|} luaO_pushvfstring: 480| 936|const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) { 481| 936| BuffFS buff; /* holds last part of the result */ 482| 936| const char *e; /* points to next '%' */ 483| 936| buff.pushed = buff.blen = 0; 484| 936| buff.L = L; 485| 2.83k| while ((e = strchr(fmt, '%')) != NULL) { ------------------ | Branch (485:10): [True: 1.89k, False: 936] ------------------ 486| 1.89k| addstr2buff(&buff, fmt, e - fmt); /* add 'fmt' up to '%' */ 487| 1.89k| switch (*(e + 1)) { /* conversion specifier */ 488| 1.38k| case 's': { /* zero-terminated string */ ------------------ | Branch (488:7): [True: 1.38k, False: 512] ------------------ 489| 1.38k| const char *s = va_arg(argp, char *); 490| 1.38k| if (s == NULL) s = "(null)"; ------------------ | Branch (490:13): [True: 0, False: 1.38k] ------------------ 491| 1.38k| addstr2buff(&buff, s, strlen(s)); 492| 1.38k| break; 493| 0| } 494| 104| case 'c': { /* an 'int' as a character */ ------------------ | Branch (494:7): [True: 104, False: 1.79k] ------------------ 495| 104| char c = cast_uchar(va_arg(argp, int)); ------------------ | | 144| 104|#define cast_uchar(i) cast(unsigned char, (i)) | | ------------------ | | | | 136| 104|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 496| 104| addstr2buff(&buff, &c, sizeof(char)); 497| 104| break; 498| 0| } 499| 408| case 'd': { /* an 'int' */ ------------------ | Branch (499:7): [True: 408, False: 1.48k] ------------------ 500| 408| TValue num; 501| 408| setivalue(&num, va_arg(argp, int)); ------------------ | | 345| 408| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 408|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 408|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 502| 408| addnum2buff(&buff, &num); 503| 408| break; 504| 0| } 505| 0| case 'I': { /* a 'lua_Integer' */ ------------------ | Branch (505:7): [True: 0, False: 1.89k] ------------------ 506| 0| TValue num; 507| 0| setivalue(&num, cast(lua_Integer, va_arg(argp, l_uacInt))); ------------------ | | 345| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 0|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 508| 0| addnum2buff(&buff, &num); 509| 0| break; 510| 0| } 511| 0| case 'f': { /* a 'lua_Number' */ ------------------ | Branch (511:7): [True: 0, False: 1.89k] ------------------ 512| 0| TValue num; 513| 0| setfltvalue(&num, cast_num(va_arg(argp, l_uacNumber))); ------------------ | | 339| 0| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 0|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 514| 0| addnum2buff(&buff, &num); 515| 0| break; 516| 0| } 517| 0| case 'p': { /* a pointer */ ------------------ | Branch (517:7): [True: 0, False: 1.89k] ------------------ 518| 0| const int sz = 3 * sizeof(void*) + 8; /* enough space for '%p' */ 519| 0| char *bf = getbuff(&buff, sz); 520| 0| void *p = va_arg(argp, void *); 521| 0| int len = lua_pointer2str(bf, sz, p); ------------------ | | 609| 0|#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p) | | ------------------ | | | | 588| 0|#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) | | ------------------ ------------------ 522| 0| addsize(&buff, len); ------------------ | | 446| 0|#define addsize(b,sz) ((b)->blen += (sz)) ------------------ 523| 0| break; 524| 0| } 525| 0| case 'U': { /* a 'long' as a UTF-8 sequence */ ------------------ | Branch (525:7): [True: 0, False: 1.89k] ------------------ 526| 0| char bf[UTF8BUFFSZ]; 527| 0| int len = luaO_utf8esc(bf, va_arg(argp, long)); 528| 0| addstr2buff(&buff, bf + UTF8BUFFSZ - len, len); ------------------ | | 797| 0|#define UTF8BUFFSZ 8 ------------------ 529| 0| break; 530| 0| } 531| 0| case '%': { ------------------ | Branch (531:7): [True: 0, False: 1.89k] ------------------ 532| 0| addstr2buff(&buff, "%", 1); 533| 0| break; 534| 0| } 535| 0| default: { ------------------ | Branch (535:7): [True: 0, False: 1.89k] ------------------ 536| 0| luaG_runerror(L, "invalid option '%%%c' to 'lua_pushfstring'", 537| 0| *(e + 1)); 538| 0| } 539| 1.89k| } 540| 1.89k| fmt = e + 2; /* skip '%' and the specifier */ 541| 1.89k| } 542| 936| addstr2buff(&buff, fmt, strlen(fmt)); /* rest of 'fmt' */ 543| 936| clearbuff(&buff); /* empty buffer into the stack */ 544| 936| lua_assert(buff.pushed == 1); ------------------ | | 114| 936|#define lua_assert(c) ((void)0) ------------------ 545| 936| return svalue(s2v(L->top.p - 1)); ------------------ | | 407| 936|#define svalue(o) getstr(tsvalue(o)) | | ------------------ | | | | 403| 936|#define getstr(ts) ((ts)->contents) | | ------------------ ------------------ 546| 936|} luaO_pushfstring: 549| 813|const char *luaO_pushfstring (lua_State *L, const char *fmt, ...) { 550| 813| const char *msg; 551| 813| va_list argp; 552| 813| va_start(argp, fmt); 553| 813| msg = luaO_pushvfstring(L, fmt, argp); 554| 813| va_end(argp); 555| 813| return msg; 556| 813|} luaO_chunkid: 567| 315|void luaO_chunkid (char *out, const char *source, size_t srclen) { 568| 315| size_t bufflen = LUA_IDSIZE; /* free space in buffer */ ------------------ | | 759| 315|#define LUA_IDSIZE 60 ------------------ 569| 315| if (*source == '=') { /* 'literal' source */ ------------------ | Branch (569:7): [True: 0, False: 315] ------------------ 570| 0| if (srclen <= bufflen) /* small enough? */ ------------------ | Branch (570:9): [True: 0, False: 0] ------------------ 571| 0| memcpy(out, source + 1, srclen * sizeof(char)); 572| 0| else { /* truncate it */ 573| 0| addstr(out, source + 1, bufflen - 1); ------------------ | | 565| 0|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 574| 0| *out = '\0'; 575| 0| } 576| 0| } 577| 315| else if (*source == '@') { /* file name */ ------------------ | Branch (577:12): [True: 0, False: 315] ------------------ 578| 0| if (srclen <= bufflen) /* small enough? */ ------------------ | Branch (578:9): [True: 0, False: 0] ------------------ 579| 0| memcpy(out, source + 1, srclen * sizeof(char)); 580| 0| else { /* add '...' before rest of name */ 581| 0| addstr(out, RETS, LL(RETS)); ------------------ | | 565| 0|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 582| 0| bufflen -= LL(RETS); ------------------ | | 70| 0|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 583| 0| memcpy(out, source + 1 + srclen - bufflen, bufflen * sizeof(char)); 584| 0| } 585| 0| } 586| 315| else { /* string; format as [string "source"] */ 587| 315| const char *nl = strchr(source, '\n'); /* find first new line (if any) */ 588| 315| addstr(out, PRE, LL(PRE)); /* add prefix */ ------------------ | | 565| 315|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 589| 315| bufflen -= LL(PRE RETS POS) + 1; /* save space for prefix+suffix+'\0' */ ------------------ | | 70| 315|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 590| 315| if (srclen < bufflen && nl == NULL) { /* small one-line source? */ ------------------ | Branch (590:9): [True: 315, False: 0] | Branch (590:29): [True: 315, False: 0] ------------------ 591| 315| addstr(out, source, srclen); /* keep it */ ------------------ | | 565| 315|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 592| 315| } 593| 0| else { 594| 0| if (nl != NULL) srclen = nl - source; /* stop at first newline */ ------------------ | Branch (594:11): [True: 0, False: 0] ------------------ 595| 0| if (srclen > bufflen) srclen = bufflen; ------------------ | Branch (595:11): [True: 0, False: 0] ------------------ 596| 0| addstr(out, source, srclen); ------------------ | | 565| 0|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 597| 0| addstr(out, RETS, LL(RETS)); ------------------ | | 565| 0|#define addstr(a,b,l) ( memcpy(a,b,(l) * sizeof(char)), a += (l) ) ------------------ 598| 0| } 599| 315| memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); ------------------ | | 563| 315|#define POS "\"]" ------------------ memcpy(out, POS, (LL(POS) + 1) * sizeof(char)); ------------------ | | 70| 315|#define LL(x) (sizeof(x)/sizeof(char) - 1) ------------------ 600| 315| } 601| 315|} lobject.c:intarith: 54| 43.7k| lua_Integer v2) { 55| 43.7k| switch (op) { 56| 214| case LUA_OPADD: return intop(+, v1, v2); ------------------ | | 215| 214|#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ ------------------ case LUA_OPADD: return intop(+, v1, v2); ------------------ | | 73| 214|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 214|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (56:5): [True: 214, False: 43.5k] ------------------ 57| 2.16k| case LUA_OPSUB:return intop(-, v1, v2); ------------------ | | 216| 2.16k|#define LUA_OPSUB 1 ------------------ case LUA_OPSUB:return intop(-, v1, v2); ------------------ | | 73| 2.16k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 2.16k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (57:5): [True: 2.16k, False: 41.5k] ------------------ 58| 2.94k| case LUA_OPMUL:return intop(*, v1, v2); ------------------ | | 217| 2.94k|#define LUA_OPMUL 2 ------------------ case LUA_OPMUL:return intop(*, v1, v2); ------------------ | | 73| 2.94k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 2.94k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (58:5): [True: 2.94k, False: 40.7k] ------------------ 59| 4.30k| case LUA_OPMOD: return luaV_mod(L, v1, v2); ------------------ | | 218| 4.30k|#define LUA_OPMOD 3 ------------------ | Branch (59:5): [True: 4.30k, False: 39.4k] ------------------ 60| 3| case LUA_OPIDIV: return luaV_idiv(L, v1, v2); ------------------ | | 221| 3|#define LUA_OPIDIV 6 ------------------ | Branch (60:5): [True: 3, False: 43.7k] ------------------ 61| 1.12k| case LUA_OPBAND: return intop(&, v1, v2); ------------------ | | 222| 1.12k|#define LUA_OPBAND 7 ------------------ case LUA_OPBAND: return intop(&, v1, v2); ------------------ | | 73| 1.12k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 1.12k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (61:5): [True: 1.12k, False: 42.6k] ------------------ 62| 21| case LUA_OPBOR: return intop(|, v1, v2); ------------------ | | 223| 21|#define LUA_OPBOR 8 ------------------ case LUA_OPBOR: return intop(|, v1, v2); ------------------ | | 73| 21|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 21|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (62:5): [True: 21, False: 43.7k] ------------------ 63| 1.15k| case LUA_OPBXOR: return intop(^, v1, v2); ------------------ | | 224| 1.15k|#define LUA_OPBXOR 9 ------------------ case LUA_OPBXOR: return intop(^, v1, v2); ------------------ | | 73| 1.15k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 1.15k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (63:5): [True: 1.15k, False: 42.5k] ------------------ 64| 170| case LUA_OPSHL: return luaV_shiftl(v1, v2); ------------------ | | 225| 170|#define LUA_OPSHL 10 ------------------ | Branch (64:5): [True: 170, False: 43.5k] ------------------ 65| 473| case LUA_OPSHR: return luaV_shiftr(v1, v2); ------------------ | | 226| 473|#define LUA_OPSHR 11 ------------------ case LUA_OPSHR: return luaV_shiftr(v1, v2); ------------------ | | 116| 473|#define luaV_shiftr(x,y) luaV_shiftl(x,intop(-, 0, y)) | | ------------------ | | | | 73| 473|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | | | ------------------ | | | | | | 161| 473|#define l_castU2S(i) ((lua_Integer)(i)) | | | | ------------------ | | ------------------ ------------------ | Branch (65:5): [True: 473, False: 43.2k] ------------------ 66| 3.20k| case LUA_OPUNM: return intop(-, 0, v1); ------------------ | | 227| 3.20k|#define LUA_OPUNM 12 ------------------ case LUA_OPUNM: return intop(-, 0, v1); ------------------ | | 73| 3.20k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 3.20k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (66:5): [True: 3.20k, False: 40.5k] ------------------ 67| 27.9k| case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1); ------------------ | | 228| 27.9k|#define LUA_OPBNOT 13 ------------------ case LUA_OPBNOT: return intop(^, ~l_castS2U(0), v1); ------------------ | | 73| 27.9k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 27.9k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ | Branch (67:5): [True: 27.9k, False: 15.7k] ------------------ 68| 0| default: lua_assert(0); return 0; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (68:5): [True: 0, False: 43.7k] ------------------ 69| 43.7k| } 70| 43.7k|} lobject.c:numarith: 74| 69.9k| lua_Number v2) { 75| 69.9k| switch (op) { 76| 421| case LUA_OPADD: return luai_numadd(L, v1, v2); ------------------ | | 215| 421|#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ ------------------ case LUA_OPADD: return luai_numadd(L, v1, v2); ------------------ | | 346| 421|#define luai_numadd(L,a,b) ((a)+(b)) ------------------ | Branch (76:5): [True: 421, False: 69.5k] ------------------ 77| 3.91k| case LUA_OPSUB: return luai_numsub(L, v1, v2); ------------------ | | 216| 3.91k|#define LUA_OPSUB 1 ------------------ case LUA_OPSUB: return luai_numsub(L, v1, v2); ------------------ | | 347| 3.91k|#define luai_numsub(L,a,b) ((a)-(b)) ------------------ | Branch (77:5): [True: 3.91k, False: 66.0k] ------------------ 78| 2.09k| case LUA_OPMUL: return luai_nummul(L, v1, v2); ------------------ | | 217| 2.09k|#define LUA_OPMUL 2 ------------------ case LUA_OPMUL: return luai_nummul(L, v1, v2); ------------------ | | 348| 2.09k|#define luai_nummul(L,a,b) ((a)*(b)) ------------------ | Branch (78:5): [True: 2.09k, False: 67.8k] ------------------ 79| 175| case LUA_OPDIV: return luai_numdiv(L, v1, v2); ------------------ | | 220| 175|#define LUA_OPDIV 5 ------------------ case LUA_OPDIV: return luai_numdiv(L, v1, v2); ------------------ | | 318| 175|#define luai_numdiv(L,a,b) ((a)/(b)) ------------------ | Branch (79:5): [True: 175, False: 69.7k] ------------------ 80| 59.0k| case LUA_OPPOW: return luai_numpow(L, v1, v2); ------------------ | | 219| 59.0k|#define LUA_OPPOW 4 ------------------ case LUA_OPPOW: return luai_numpow(L, v1, v2); ------------------ | | 341| 59.0k| ((void)L, (b == 2) ? (a)*(a) : l_mathop(pow)(a,b)) | | ------------------ | | | | 473| 46.8k|#define l_mathop(op) op | | ------------------ | | | Branch (341:13): [True: 12.2k, False: 46.8k] | | ------------------ ------------------ | Branch (80:5): [True: 59.0k, False: 10.8k] ------------------ 81| 37| case LUA_OPIDIV: return luai_numidiv(L, v1, v2); ------------------ | | 221| 37|#define LUA_OPIDIV 6 ------------------ case LUA_OPIDIV: return luai_numidiv(L, v1, v2); ------------------ | | 313| 37|#define luai_numidiv(L,a,b) ((void)L, l_floor(luai_numdiv(L,a,b))) | | ------------------ | | | | 409| 37|#define l_floor(x) (l_mathop(floor)(x)) | | | | ------------------ | | | | | | 473| 37|#define l_mathop(op) op | | | | ------------------ | | ------------------ ------------------ | Branch (81:5): [True: 37, False: 69.9k] ------------------ 82| 2.71k| case LUA_OPUNM: return luai_numunm(L, v1); ------------------ | | 227| 2.71k|#define LUA_OPUNM 12 ------------------ case LUA_OPUNM: return luai_numunm(L, v1); ------------------ | | 349| 2.71k|#define luai_numunm(L,a) (-(a)) ------------------ | Branch (82:5): [True: 2.71k, False: 67.2k] ------------------ 83| 1.53k| case LUA_OPMOD: return luaV_modf(L, v1, v2); ------------------ | | 218| 1.53k|#define LUA_OPMOD 3 ------------------ | Branch (83:5): [True: 1.53k, False: 68.4k] ------------------ 84| 0| default: lua_assert(0); return 0; ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ | Branch (84:5): [True: 0, False: 69.9k] ------------------ 85| 69.9k| } 86| 69.9k|} lobject.c:l_str2int: 276| 224k|static const char *l_str2int (const char *s, lua_Integer *result) { 277| 224k| lua_Unsigned a = 0; 278| 224k| int empty = 1; 279| 224k| int neg; 280| 224k| while (lisspace(cast_uchar(*s))) s++; /* skip initial spaces */ 281| 224k| neg = isneg(&s); 282| 224k| if (s[0] == '0' && ------------------ | Branch (282:7): [True: 43.8k, False: 180k] ------------------ 283| 224k| (s[1] == 'x' || s[1] == 'X')) { /* hex? */ ------------------ | Branch (283:8): [True: 0, False: 43.8k] | Branch (283:23): [True: 0, False: 43.8k] ------------------ 284| 0| s += 2; /* skip '0x' */ 285| 0| for (; lisxdigit(cast_uchar(*s)); s++) { 286| 0| a = a * 16 + luaO_hexavalue(*s); 287| 0| empty = 0; 288| 0| } 289| 0| } 290| 224k| else { /* decimal */ 291| 461k| for (; lisdigit(cast_uchar(*s)); s++) { 292| 461k| int d = *s - '0'; 293| 461k| if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 273| 461k|#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) | | ------------------ | | | | 136| 922k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 273| 3.53k|#define MAXBY10 cast(lua_Unsigned, LUA_MAXINTEGER / 10) | | ------------------ | | | | 136| 7.07k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ if (a >= MAXBY10 && (a > MAXBY10 || d > MAXLASTD + neg)) /* overflow? */ ------------------ | | 274| 1.79k|#define MAXLASTD cast_int(LUA_MAXINTEGER % 10) | | ------------------ | | | | 141| 1.79k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 1.79k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (293:11): [True: 3.53k, False: 457k] | Branch (293:28): [True: 1.73k, False: 1.79k] | Branch (293:43): [True: 0, False: 1.79k] ------------------ 294| 1.73k| return NULL; /* do not accept it (as integer) */ 295| 459k| a = a * 10 + d; 296| 459k| empty = 0; 297| 459k| } 298| 224k| } 299| 222k| while (lisspace(cast_uchar(*s))) s++; /* skip trailing spaces */ 300| 222k| if (empty || *s != '\0') return NULL; /* something wrong in the numeral */ ------------------ | Branch (300:7): [True: 1.56k, False: 220k] | Branch (300:16): [True: 19.6k, False: 201k] ------------------ 301| 201k| else { 302| 201k| *result = l_castU2S((neg) ? 0u - a : a); ------------------ | | 161| 402k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ | | | Branch (161:37): [True: 0, False: 201k] | | ------------------ ------------------ 303| 201k| return s; 304| 201k| } 305| 222k|} lobject.c:isneg: 141| 224k|static int isneg (const char **s) { 142| 224k| if (**s == '-') { (*s)++; return 1; } ------------------ | Branch (142:7): [True: 0, False: 224k] ------------------ 143| 224k| else if (**s == '+') (*s)++; ------------------ | Branch (143:12): [True: 0, False: 224k] ------------------ 144| 224k| return 0; 145| 224k|} lobject.c:l_str2d: 251| 22.9k|static const char *l_str2d (const char *s, lua_Number *result) { 252| 22.9k| const char *endptr; 253| 22.9k| const char *pmode = strpbrk(s, ".xXnN"); /* look for special chars */ 254| 22.9k| int mode = pmode ? ltolower(cast_uchar(*pmode)) : 0; ------------------ | | 72| 18.2k| check_exp(('A' <= (c) && (c) <= 'Z') || (c) == ((c) | ('A' ^ 'a')), \ | | ------------------ | | | | 115| 18.2k|#define check_exp(c,e) (e) | | ------------------ | | 73| 22.9k| (c) | ('A' ^ 'a')) ------------------ | Branch (254:14): [True: 18.2k, False: 4.73k] ------------------ 255| 22.9k| if (mode == 'n') /* reject 'inf' and 'nan' */ ------------------ | Branch (255:7): [True: 8, False: 22.9k] ------------------ 256| 8| return NULL; 257| 22.9k| endptr = l_str2dloc(s, result, mode); /* try to convert */ 258| 22.9k| if (endptr == NULL) { /* failed? may be a different locale */ ------------------ | Branch (258:7): [True: 10, False: 22.9k] ------------------ 259| 10| char buff[L_MAXLENNUM + 1]; 260| 10| const char *pdot = strchr(s, '.'); 261| 10| if (pdot == NULL || strlen(s) > L_MAXLENNUM) ------------------ | | 220| 7|#define L_MAXLENNUM 200 ------------------ | Branch (261:9): [True: 3, False: 7] | Branch (261:25): [True: 6, False: 1] ------------------ 262| 9| return NULL; /* string too long or no dot; fail */ 263| 1| strcpy(buff, s); /* copy string to buffer */ 264| 1| buff[pdot - s] = lua_getlocaledecpoint(); /* correct decimal point */ ------------------ | | 662| 1|#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) ------------------ 265| 1| endptr = l_str2dloc(buff, result, mode); /* try again */ 266| 1| if (endptr != NULL) ------------------ | Branch (266:9): [True: 0, False: 1] ------------------ 267| 0| endptr = s + (endptr - buff); /* make relative to 's' */ 268| 1| } 269| 22.9k| return endptr; 270| 22.9k|} lobject.c:l_str2dloc: 228| 22.9k|static const char *l_str2dloc (const char *s, lua_Number *result, int mode) { 229| 22.9k| char *endptr; 230| | *result = (mode == 'x') ? lua_strx2number(s, &endptr) /* try to convert */ ------------------ | | 601| 0|#define lua_strx2number(s,p) lua_str2number(s,p) | | ------------------ | | | | 475| 0|#define lua_str2number(s,p) strtod((s), (p)) | | ------------------ ------------------ | Branch (230:13): [True: 0, False: 22.9k] ------------------ 231| 22.9k| : lua_str2number(s, &endptr); ------------------ | | 475| 45.9k|#define lua_str2number(s,p) strtod((s), (p)) ------------------ 232| 22.9k| if (endptr == s) return NULL; /* nothing recognized? */ ------------------ | Branch (232:7): [True: 8, False: 22.9k] ------------------ 233| 22.9k| while (lisspace(cast_uchar(*endptr))) endptr++; /* skip trailing spaces */ 234| 22.9k| return (*endptr == '\0') ? endptr : NULL; /* OK iff no trailing chars */ ------------------ | Branch (234:10): [True: 22.9k, False: 3] ------------------ 235| 22.9k|} lobject.c:tostringbuff: 355| 148k|static int tostringbuff (TValue *obj, char *buff) { 356| 148k| int len; 357| 148k| lua_assert(ttisnumber(obj)); ------------------ | | 114| 148k|#define lua_assert(c) ((void)0) ------------------ 358| 148k| if (ttisinteger(obj)) ------------------ | | 328| 148k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 148k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 148k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 83.1k, False: 64.9k] | | | | ------------------ | | ------------------ ------------------ 359| 83.1k| len = lua_integer2str(buff, MAXNUMBER2STR, ivalue(obj)); ------------------ | | 505| 83.1k| l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) | | ------------------ | | | | 588| 83.1k|#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) | | ------------------ ------------------ 360| 64.9k| else { 361| 64.9k| len = lua_number2str(buff, MAXNUMBER2STR, fltvalue(obj)); ------------------ | | 412| 64.9k| l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) | | ------------------ | | | | 588| 64.9k|#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) | | ------------------ ------------------ 362| 64.9k| if (buff[strspn(buff, "-0123456789")] == '\0') { /* looks like an int? */ ------------------ | Branch (362:9): [True: 64.3k, False: 551] ------------------ 363| 64.3k| buff[len++] = lua_getlocaledecpoint(); ------------------ | | 662| 64.3k|#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) ------------------ 364| 64.3k| buff[len++] = '0'; /* adds '.0' to result */ 365| 64.3k| } 366| 64.9k| } 367| 148k| return len; 368| 148k|} lobject.c:addstr2buff: 453| 4.31k|static void addstr2buff (BuffFS *buff, const char *str, size_t slen) { 454| 4.31k| if (slen <= BUFVFS) { /* does string fit into buffer? */ ------------------ | | 394| 4.31k|#define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 759| 4.31k|#define LUA_IDSIZE 60 | | ------------------ | | #define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 349| 4.31k|#define MAXNUMBER2STR 44 | | ------------------ ------------------ | Branch (454:7): [True: 4.26k, False: 56] ------------------ 455| 4.26k| char *bf = getbuff(buff, cast_int(slen)); ------------------ | | 141| 4.26k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 4.26k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 456| 4.26k| memcpy(bf, str, slen); /* add string to buffer */ 457| 4.26k| addsize(buff, cast_int(slen)); ------------------ | | 446| 4.26k|#define addsize(b,sz) ((b)->blen += (sz)) ------------------ 458| 4.26k| } 459| 56| else { /* string larger than buffer */ 460| 56| clearbuff(buff); /* string comes after buffer's content */ 461| 56| pushstr(buff, str, slen); /* push string */ 462| 56| } 463| 4.31k|} lobject.c:pushstr: 414| 1.05k|static void pushstr (BuffFS *buff, const char *str, size_t lstr) { 415| 1.05k| lua_State *L = buff->L; 416| 1.05k| setsvalue2s(L, L->top.p, luaS_newlstr(L, str, lstr)); ------------------ | | 377| 1.05k|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 1.05k| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 1.05k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 1.05k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 1.05k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 1.05k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 1.05k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 1.05k| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 1.05k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 1.05k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 1.05k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 417| 1.05k| L->top.p++; /* may use one slot from EXTRA_STACK */ 418| 1.05k| if (!buff->pushed) /* no previous string on the stack? */ ------------------ | Branch (418:7): [True: 936, False: 115] ------------------ 419| 936| buff->pushed = 1; /* now there is one */ 420| 115| else /* join previous string with new one */ 421| 115| luaV_concat(L, 2); 422| 1.05k|} lobject.c:addnum2buff: 469| 408|static void addnum2buff (BuffFS *buff, TValue *num) { 470| 408| char *numbuff = getbuff(buff, MAXNUMBER2STR); ------------------ | | 349| 408|#define MAXNUMBER2STR 44 ------------------ 471| 408| int len = tostringbuff(num, numbuff); /* format number into 'numbuff' */ 472| 408| addsize(buff, len); ------------------ | | 446| 408|#define addsize(b,sz) ((b)->blen += (sz)) ------------------ 473| 408|} lobject.c:getbuff: 438| 4.67k|static char *getbuff (BuffFS *buff, int sz) { 439| 4.67k| lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS); ------------------ | | 114| 4.67k|#define lua_assert(c) ((void)0) ------------------ lua_assert(buff->blen <= BUFVFS); lua_assert(sz <= BUFVFS); ------------------ | | 114| 4.67k|#define lua_assert(c) ((void)0) ------------------ 440| 4.67k| if (sz > BUFVFS - buff->blen) /* not enough space? */ ------------------ | | 394| 4.67k|#define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 759| 4.67k|#define LUA_IDSIZE 60 | | ------------------ | | #define BUFVFS (LUA_IDSIZE + MAXNUMBER2STR + 95) | | ------------------ | | | | 349| 4.67k|#define MAXNUMBER2STR 44 | | ------------------ ------------------ | Branch (440:7): [True: 3, False: 4.66k] ------------------ 441| 3| clearbuff(buff); 442| 4.67k| return buff->space + buff->blen; 443| 4.67k|} lobject.c:clearbuff: 428| 995|static void clearbuff (BuffFS *buff) { 429| 995| pushstr(buff, buff->space, buff->blen); /* push buffer contents */ 430| 995| buff->blen = 0; /* space now is empty */ 431| 995|} luaY_nvarstack: 243| 18.4M|int luaY_nvarstack (FuncState *fs) { 244| 18.4M| return reglevel(fs, fs->nactvar); 245| 18.4M|} luaY_parser: 1943| 258| Dyndata *dyd, const char *name, int firstchar) { 1944| 258| LexState lexstate; 1945| 258| FuncState funcstate; 1946| 258| LClosure *cl = luaF_newLclosure(L, 1); /* create main closure */ 1947| 258| setclLvalue2s(L, L->top.p, cl); /* anchor it (to avoid being collected) */ ------------------ | | 615| 258|#define setclLvalue2s(L,o,cl) setclLvalue(L,s2v(o),cl) | | ------------------ | | | | 611| 258| { TValue *io = (obj); LClosure *x_ = (x); \ | | | | 612| 258| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 72| 258|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 390| 258|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 258|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 114| 258|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 613| 258| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 258| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 258|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 258| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1948| 258| luaD_inctop(L); 1949| 258| lexstate.h = luaH_new(L); /* create table for scanner */ 1950| 258| sethvalue2s(L, L->top.p, lexstate.h); /* anchor it */ ------------------ | | 691| 258|#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) | | ------------------ | | | | 687| 258| { TValue *io = (obj); Table *x_ = (x); \ | | | | 688| 258| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 72| 258|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 390| 258|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 258|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 114| 258|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 689| 258| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 258| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 258|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 258| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1951| 258| luaD_inctop(L); 1952| 258| funcstate.f = cl->p = luaF_newproto(L); 1953| 258| luaC_objbarrier(L, cl, cl->p); ------------------ | | 175| 258|#define luaC_objbarrier(L,p,o) ( \ | | 176| 258| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 258|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 258|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 516|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 258] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 258| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 258|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1954| 258| funcstate.f->source = luaS_new(L, name); /* create and anchor TString */ 1955| 258| luaC_objbarrier(L, funcstate.f, funcstate.f->source); ------------------ | | 175| 258|#define luaC_objbarrier(L,p,o) ( \ | | 176| 258| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 258|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 258|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 516|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 258] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 258| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 258|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1956| 258| lexstate.buff = buff; 1957| 258| lexstate.dyd = dyd; 1958| 258| dyd->actvar.n = dyd->gt.n = dyd->label.n = 0; 1959| 258| luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar); 1960| 258| mainfunc(&lexstate, &funcstate); 1961| 258| lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs); ------------------ | | 114| 258|#define lua_assert(c) ((void)0) ------------------ 1962| | /* all scopes should be correctly finished */ 1963| 258| lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0); ------------------ | | 114| 258|#define lua_assert(c) ((void)0) ------------------ 1964| 258| L->top.p--; /* remove scanner's table */ 1965| 258| return cl; /* closure is on the stack, too */ 1966| 258|} lparser.c:reglevel: 229| 18.4M|static int reglevel (FuncState *fs, int nvar) { 230| 19.1M| while (nvar-- > 0) { ------------------ | Branch (230:10): [True: 12.2M, False: 6.94M] ------------------ 231| 12.2M| Vardesc *vd = getlocalvardesc(fs, nvar); /* get previous variable */ 232| 12.2M| if (vd->vd.kind != RDKCTC) /* is in a register? */ ------------------ | | 93| 12.2M|#define RDKCTC 3 /* compile-time constant */ ------------------ | Branch (232:9): [True: 11.5M, False: 725k] ------------------ 233| 11.5M| return vd->vd.ridx + 1; 234| 12.2M| } 235| 6.94M| return 0; /* no variables in registers */ 236| 18.4M|} lparser.c:getlocalvardesc: 219| 71.2M|static Vardesc *getlocalvardesc (FuncState *fs, int vidx) { 220| 71.2M| return &fs->ls->dyd->actvar.arr[fs->firstlocal + vidx]; 221| 71.2M|} lparser.c:mainfunc: 1924| 258|static void mainfunc (LexState *ls, FuncState *fs) { 1925| 258| BlockCnt bl; 1926| 258| Upvaldesc *env; 1927| 258| open_func(ls, fs, &bl); 1928| 258| setvararg(fs, 0); /* main function is always declared vararg */ 1929| 258| env = allocupvalue(fs); /* ...set environment upvalue */ 1930| 258| env->instack = 1; 1931| 258| env->idx = 0; 1932| 258| env->kind = VDKREG; ------------------ | | 90| 258|#define VDKREG 0 /* regular */ ------------------ 1933| 258| env->name = ls->envn; 1934| 258| luaC_objbarrier(ls->L, fs->f, env->name); ------------------ | | 175| 258|#define luaC_objbarrier(L,p,o) ( \ | | 176| 258| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 258|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 258|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 516|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 258] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 258| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 258|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1935| 258| luaX_next(ls); /* read first token */ 1936| 258| statlist(ls); /* parse main body */ 1937| 258| check(ls, TK_EOS); 1938| 258| close_func(ls); 1939| 258|} lparser.c:open_func: 729| 4.49k|static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) { 730| 4.49k| Proto *f = fs->f; 731| 4.49k| fs->prev = ls->fs; /* linked list of funcstates */ 732| 4.49k| fs->ls = ls; 733| 4.49k| ls->fs = fs; 734| 4.49k| fs->pc = 0; 735| 4.49k| fs->previousline = f->linedefined; 736| 4.49k| fs->iwthabs = 0; 737| 4.49k| fs->lasttarget = 0; 738| 4.49k| fs->freereg = 0; 739| 4.49k| fs->nk = 0; 740| 4.49k| fs->nabslineinfo = 0; 741| 4.49k| fs->np = 0; 742| 4.49k| fs->nups = 0; 743| 4.49k| fs->ndebugvars = 0; 744| 4.49k| fs->nactvar = 0; 745| 4.49k| fs->needclose = 0; 746| 4.49k| fs->firstlocal = ls->dyd->actvar.n; 747| 4.49k| fs->firstlabel = ls->dyd->label.n; 748| 4.49k| fs->bl = NULL; 749| 4.49k| f->source = ls->source; 750| 4.49k| luaC_objbarrier(ls->L, f, f->source); ------------------ | | 175| 4.49k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 4.49k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 4.49k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 4.49k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 8.99k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 4.49k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 4.49k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 4.49k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 4.49k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 751| 4.49k| f->maxstacksize = 2; /* registers 0/1 are always valid */ 752| 4.49k| enterblock(fs, bl, 0); 753| 4.49k|} lparser.c:enterblock: 642| 8.60k|static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) { 643| 8.60k| bl->isloop = isloop; 644| 8.60k| bl->nactvar = fs->nactvar; 645| 8.60k| bl->firstlabel = fs->ls->dyd->label.n; 646| 8.60k| bl->firstgoto = fs->ls->dyd->gt.n; 647| 8.60k| bl->upval = 0; 648| 8.60k| bl->insidetbc = (fs->bl != NULL && fs->bl->insidetbc); ------------------ | Branch (648:20): [True: 4.11k, False: 4.49k] | Branch (648:38): [True: 507, False: 3.60k] ------------------ 649| 8.60k| bl->previous = fs->bl; 650| 8.60k| fs->bl = bl; 651| 8.60k| lua_assert(fs->freereg == luaY_nvarstack(fs)); ------------------ | | 114| 8.60k|#define lua_assert(c) ((void)0) ------------------ 652| 8.60k|} lparser.c:setvararg: 953| 310|static void setvararg (FuncState *fs, int nparams) { 954| 310| fs->f->is_vararg = 1; 955| 310| luaK_codeABC(fs, OP_VARARGPREP, nparams, 0, 0); ------------------ | | 48| 310|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 956| 310|} lparser.c:allocupvalue: 352| 1.89k|static Upvaldesc *allocupvalue (FuncState *fs) { 353| 1.89k| Proto *f = fs->f; 354| 1.89k| int oldsize = f->sizeupvalues; 355| 1.89k| checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues"); ------------------ | | 29| 1.89k|#define MAXUPVAL 255 ------------------ 356| 1.89k| luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues, ------------------ | | 67| 1.89k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 3.78k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 1.89k| luaM_limitN(limit,t),e))) ------------------ 357| 1.89k| Upvaldesc, MAXUPVAL, "upvalues"); 358| 7.98k| while (oldsize < f->sizeupvalues) ------------------ | Branch (358:10): [True: 6.09k, False: 1.89k] ------------------ 359| 6.09k| f->upvalues[oldsize++].name = NULL; 360| 1.89k| return &f->upvalues[fs->nups++]; 361| 1.89k|} lparser.c:checklimit: 87| 8.86k|static void checklimit (FuncState *fs, int v, int l, const char *what) { 88| 8.86k| if (v > l) errorlimit(fs, l, what); ------------------ | Branch (88:7): [True: 2, False: 8.85k] ------------------ 89| 8.86k|} lparser.c:errorlimit: 74| 2|static l_noret errorlimit (FuncState *fs, int limit, const char *what) { 75| 2| lua_State *L = fs->ls->L; 76| 2| const char *msg; 77| 2| int line = fs->f->linedefined; 78| 2| const char *where = (line == 0) ------------------ | Branch (78:23): [True: 0, False: 2] ------------------ 79| 2| ? "main function" 80| 2| : luaO_pushfstring(L, "function at line %d", line); 81| 2| msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s", 82| 2| what, limit, where); 83| 2| luaX_syntaxerror(fs->ls, msg); 84| 2|} lparser.c:statlist: 799| 6.94k|static void statlist (LexState *ls) { 800| | /* statlist -> { stat [';'] } */ 801| 52.6k| while (!block_follow(ls, 1)) { ------------------ | Branch (801:10): [True: 49.4k, False: 3.22k] ------------------ 802| 49.4k| if (ls->t.token == TK_RETURN) { ------------------ | Branch (802:9): [True: 3.71k, False: 45.7k] ------------------ 803| 3.71k| statement(ls); 804| 3.71k| return; /* 'return' must be last statement */ 805| 3.71k| } 806| 45.7k| statement(ls); 807| 45.7k| } 808| 6.94k|} lparser.c:block_follow: 788| 56.0k|static int block_follow (LexState *ls, int withuntil) { 789| 56.0k| switch (ls->t.token) { 790| 214| case TK_ELSE: case TK_ELSEIF: ------------------ | Branch (790:5): [True: 25, False: 56.0k] | Branch (790:19): [True: 189, False: 55.8k] ------------------ 791| 2.05k| case TK_END: case TK_EOS: ------------------ | Branch (791:5): [True: 1.78k, False: 54.2k] | Branch (791:18): [True: 53, False: 55.9k] ------------------ 792| 2.05k| return 1; 793| 310| case TK_UNTIL: return withuntil; ------------------ | Branch (793:5): [True: 310, False: 55.7k] ------------------ 794| 53.6k| default: return 0; ------------------ | Branch (794:5): [True: 53.6k, False: 2.36k] ------------------ 795| 56.0k| } 796| 56.0k|} lparser.c:statement: 1845| 49.7k|static void statement (LexState *ls) { 1846| 49.7k| int line = ls->linenumber; /* may be needed for error messages */ 1847| 49.7k| enterlevel(ls); ------------------ | | 504| 49.7k|#define enterlevel(ls) luaE_incCstack(ls->L) ------------------ 1848| 49.7k| switch (ls->t.token) { 1849| 13.2k| case ';': { /* stat -> ';' (empty statement) */ ------------------ | Branch (1849:5): [True: 13.2k, False: 36.5k] ------------------ 1850| 13.2k| luaX_next(ls); /* skip ';' */ 1851| 13.2k| break; 1852| 0| } 1853| 646| case TK_IF: { /* stat -> ifstat */ ------------------ | Branch (1853:5): [True: 646, False: 49.1k] ------------------ 1854| 646| ifstat(ls, line); 1855| 646| break; 1856| 0| } 1857| 23| case TK_WHILE: { /* stat -> whilestat */ ------------------ | Branch (1857:5): [True: 23, False: 49.7k] ------------------ 1858| 23| whilestat(ls, line); 1859| 23| break; 1860| 0| } 1861| 1.09k| case TK_DO: { /* stat -> DO block END */ ------------------ | Branch (1861:5): [True: 1.09k, False: 48.6k] ------------------ 1862| 1.09k| luaX_next(ls); /* skip DO */ 1863| 1.09k| block(ls); 1864| 1.09k| check_match(ls, TK_END, TK_DO, line); 1865| 1.09k| break; 1866| 0| } 1867| 447| case TK_FOR: { /* stat -> forstat */ ------------------ | Branch (1867:5): [True: 447, False: 49.3k] ------------------ 1868| 447| forstat(ls, line); 1869| 447| break; 1870| 0| } 1871| 319| case TK_REPEAT: { /* stat -> repeatstat */ ------------------ | Branch (1871:5): [True: 319, False: 49.4k] ------------------ 1872| 319| repeatstat(ls, line); 1873| 319| break; 1874| 0| } 1875| 3.21k| case TK_FUNCTION: { /* stat -> funcstat */ ------------------ | Branch (1875:5): [True: 3.21k, False: 46.5k] ------------------ 1876| 3.21k| funcstat(ls, line); 1877| 3.21k| break; 1878| 0| } 1879| 3.70k| case TK_LOCAL: { /* stat -> localstat */ ------------------ | Branch (1879:5): [True: 3.70k, False: 46.0k] ------------------ 1880| 3.70k| luaX_next(ls); /* skip LOCAL */ 1881| 3.70k| if (testnext(ls, TK_FUNCTION)) /* local function? */ ------------------ | Branch (1881:11): [True: 928, False: 2.78k] ------------------ 1882| 928| localfunc(ls); 1883| 2.78k| else 1884| 2.78k| localstat(ls); 1885| 3.70k| break; 1886| 0| } 1887| 146| case TK_DBCOLON: { /* stat -> label */ ------------------ | Branch (1887:5): [True: 146, False: 49.6k] ------------------ 1888| 146| luaX_next(ls); /* skip double colon */ 1889| 146| labelstat(ls, str_checkname(ls), line); 1890| 146| break; 1891| 0| } 1892| 3.71k| case TK_RETURN: { /* stat -> retstat */ ------------------ | Branch (1892:5): [True: 3.71k, False: 46.0k] ------------------ 1893| 3.71k| luaX_next(ls); /* skip RETURN */ 1894| 3.71k| retstat(ls); 1895| 3.71k| break; 1896| 0| } 1897| 754| case TK_BREAK: { /* stat -> breakstat */ ------------------ | Branch (1897:5): [True: 754, False: 49.0k] ------------------ 1898| 754| breakstat(ls); 1899| 754| break; 1900| 0| } 1901| 1.28k| case TK_GOTO: { /* stat -> 'goto' NAME */ ------------------ | Branch (1901:5): [True: 1.28k, False: 48.4k] ------------------ 1902| 1.28k| luaX_next(ls); /* skip 'goto' */ 1903| 1.28k| gotostat(ls); 1904| 1.28k| break; 1905| 0| } 1906| 21.2k| default: { /* stat -> func | assignment */ ------------------ | Branch (1906:5): [True: 21.2k, False: 28.5k] ------------------ 1907| 21.2k| exprstat(ls); 1908| 21.2k| break; 1909| 0| } 1910| 49.7k| } 1911| 48.4k| lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg && ------------------ | | 114| 48.4k|#define lua_assert(c) ((void)0) ------------------ 1912| 48.4k| ls->fs->freereg >= luaY_nvarstack(ls->fs)); 1913| 48.4k| ls->fs->freereg = luaY_nvarstack(ls->fs); /* free registers */ 1914| 48.4k| leavelevel(ls); ------------------ | | 507| 48.4k|#define leavelevel(ls) ((ls)->L->nCcalls--) ------------------ 1915| 48.4k|} lparser.c:ifstat: 1675| 646|static void ifstat (LexState *ls, int line) { 1676| | /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */ 1677| 646| FuncState *fs = ls->fs; 1678| 646| int escapelist = NO_JUMP; /* exit list for finished parts */ ------------------ | | 20| 646|#define NO_JUMP (-1) ------------------ 1679| 646| test_then_block(ls, &escapelist); /* IF cond THEN block */ 1680| 976| while (ls->t.token == TK_ELSEIF) ------------------ | Branch (1680:10): [True: 330, False: 646] ------------------ 1681| 330| test_then_block(ls, &escapelist); /* ELSEIF cond THEN block */ 1682| 646| if (testnext(ls, TK_ELSE)) ------------------ | Branch (1682:7): [True: 25, False: 621] ------------------ 1683| 25| block(ls); /* 'else' part */ 1684| 646| check_match(ls, TK_END, TK_IF, line); 1685| 646| luaK_patchtohere(fs, escapelist); /* patch escape list to 'if' end */ 1686| 646|} lparser.c:test_then_block: 1638| 976|static void test_then_block (LexState *ls, int *escapelist) { 1639| | /* test_then_block -> [IF | ELSEIF] cond THEN block */ 1640| 976| BlockCnt bl; 1641| 976| FuncState *fs = ls->fs; 1642| 976| expdesc v; 1643| 976| int jf; /* instruction to skip 'then' code (if condition is false) */ 1644| 976| luaX_next(ls); /* skip IF or ELSEIF */ 1645| 976| expr(ls, &v); /* read condition */ 1646| 976| checknext(ls, TK_THEN); 1647| 976| if (ls->t.token == TK_BREAK) { /* 'if x then break' ? */ ------------------ | Branch (1647:7): [True: 798, False: 178] ------------------ 1648| 798| int line = ls->linenumber; 1649| 798| luaK_goiffalse(ls->fs, &v); /* will jump if condition is true */ 1650| 798| luaX_next(ls); /* skip 'break' */ 1651| 798| enterblock(fs, &bl, 0); /* must enter block before 'goto' */ 1652| 798| newgotoentry(ls, luaS_newliteral(ls->L, "break"), line, v.t); ------------------ | | 28| 798|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 798| (sizeof(s)/sizeof(char))-1)) ------------------ 1653| 1.85k| while (testnext(ls, ';')) {} /* skip semicolons */ ------------------ | Branch (1653:12): [True: 1.05k, False: 798] ------------------ 1654| 798| if (block_follow(ls, 0)) { /* jump is the entire block? */ ------------------ | Branch (1654:9): [True: 417, False: 381] ------------------ 1655| 417| leaveblock(fs); 1656| 417| return; /* and that is it */ 1657| 417| } 1658| 381| else /* must skip over 'then' part if condition is false */ 1659| 381| jf = luaK_jump(fs); 1660| 798| } 1661| 178| else { /* regular case (not a break) */ 1662| 178| luaK_goiftrue(ls->fs, &v); /* skip over block if condition is false */ 1663| 178| enterblock(fs, &bl, 0); 1664| 178| jf = v.f; 1665| 178| } 1666| 559| statlist(ls); /* 'then' part */ 1667| 559| leaveblock(fs); 1668| 559| if (ls->t.token == TK_ELSE || ------------------ | Branch (1668:7): [True: 158, False: 401] ------------------ 1669| 559| ls->t.token == TK_ELSEIF) /* followed by 'else'/'elseif'? */ ------------------ | Branch (1669:7): [True: 198, False: 203] ------------------ 1670| 223| luaK_concat(fs, escapelist, luaK_jump(fs)); /* must jump over it */ 1671| 559| luaK_patchtohere(fs, jf); 1672| 559|} lparser.c:expr: 1290| 103k|static void expr (LexState *ls, expdesc *v) { 1291| 103k| subexpr(ls, v, 0); 1292| 103k|} lparser.c:subexpr: 1260| 7.61M|static BinOpr subexpr (LexState *ls, expdesc *v, int limit) { 1261| 7.61M| BinOpr op; 1262| 7.61M| UnOpr uop; 1263| 7.61M| enterlevel(ls); ------------------ | | 504| 7.61M|#define enterlevel(ls) luaE_incCstack(ls->L) ------------------ 1264| 7.61M| uop = getunopr(ls->t.token); 1265| 7.61M| if (uop != OPR_NOUNOPR) { /* prefix (unary) operator? */ ------------------ | Branch (1265:7): [True: 197k, False: 7.41M] ------------------ 1266| 197k| int line = ls->linenumber; 1267| 197k| luaX_next(ls); /* skip operator */ 1268| 197k| subexpr(ls, v, UNARY_PRIORITY); ------------------ | | 1253| 197k|#define UNARY_PRIORITY 12 /* priority for unary operators */ ------------------ 1269| 197k| luaK_prefix(ls->fs, uop, v, line); 1270| 197k| } 1271| 7.41M| else simpleexp(ls, v); 1272| | /* expand while operators have priorities higher than 'limit' */ 1273| 7.61M| op = getbinopr(ls->t.token); 1274| 14.9M| while (op != OPR_NOBINOPR && priority[op].left > limit) { ------------------ | Branch (1274:10): [True: 14.7M, False: 178k] | Branch (1274:32): [True: 7.31M, False: 7.43M] ------------------ 1275| 7.31M| expdesc v2; 1276| 7.31M| BinOpr nextop; 1277| 7.31M| int line = ls->linenumber; 1278| 7.31M| luaX_next(ls); /* skip operator */ 1279| 7.31M| luaK_infix(ls->fs, op, v); 1280| | /* read sub-expression with higher priority */ 1281| 7.31M| nextop = subexpr(ls, &v2, priority[op].right); 1282| 7.31M| luaK_posfix(ls->fs, op, v, &v2, line); 1283| 7.31M| op = nextop; 1284| 7.31M| } 1285| 7.61M| leavelevel(ls); ------------------ | | 507| 7.61M|#define leavelevel(ls) ((ls)->L->nCcalls--) ------------------ 1286| 7.61M| return op; /* return first untreated operator */ 1287| 7.61M|} lparser.c:getunopr: 1195| 7.61M|static UnOpr getunopr (int op) { 1196| 7.61M| switch (op) { 1197| 6.63k| case TK_NOT: return OPR_NOT; ------------------ | Branch (1197:5): [True: 6.63k, False: 7.60M] ------------------ 1198| 98.8k| case '-': return OPR_MINUS; ------------------ | Branch (1198:5): [True: 98.8k, False: 7.51M] ------------------ 1199| 72.3k| case '~': return OPR_BNOT; ------------------ | Branch (1199:5): [True: 72.3k, False: 7.54M] ------------------ 1200| 19.9k| case '#': return OPR_LEN; ------------------ | Branch (1200:5): [True: 19.9k, False: 7.59M] ------------------ 1201| 7.41M| default: return OPR_NOUNOPR; ------------------ | Branch (1201:5): [True: 7.41M, False: 197k] ------------------ 1202| 7.61M| } 1203| 7.61M|} lparser.c:simpleexp: 1140| 7.41M|static void simpleexp (LexState *ls, expdesc *v) { 1141| | /* simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... | 1142| | constructor | FUNCTION body | suffixedexp */ 1143| 7.41M| switch (ls->t.token) { 1144| 22.9k| case TK_FLT: { ------------------ | Branch (1144:5): [True: 22.9k, False: 7.39M] ------------------ 1145| 22.9k| init_exp(v, VKFLT, 0); 1146| 22.9k| v->u.nval = ls->t.seminfo.r; 1147| 22.9k| break; 1148| 0| } 1149| 201k| case TK_INT: { ------------------ | Branch (1149:5): [True: 201k, False: 7.21M] ------------------ 1150| 201k| init_exp(v, VKINT, 0); 1151| 201k| v->u.ival = ls->t.seminfo.i; 1152| 201k| break; 1153| 0| } 1154| 5.50k| case TK_STRING: { ------------------ | Branch (1154:5): [True: 5.50k, False: 7.41M] ------------------ 1155| 5.50k| codestring(v, ls->t.seminfo.ts); 1156| 5.50k| break; 1157| 0| } 1158| 50.5k| case TK_NIL: { ------------------ | Branch (1158:5): [True: 50.5k, False: 7.36M] ------------------ 1159| 50.5k| init_exp(v, VNIL, 0); 1160| 50.5k| break; 1161| 0| } 1162| 1.26k| case TK_TRUE: { ------------------ | Branch (1162:5): [True: 1.26k, False: 7.41M] ------------------ 1163| 1.26k| init_exp(v, VTRUE, 0); 1164| 1.26k| break; 1165| 0| } 1166| 607| case TK_FALSE: { ------------------ | Branch (1166:5): [True: 607, False: 7.41M] ------------------ 1167| 607| init_exp(v, VFALSE, 0); 1168| 607| break; 1169| 0| } 1170| 306| case TK_DOTS: { /* vararg */ ------------------ | Branch (1170:5): [True: 306, False: 7.41M] ------------------ 1171| 306| FuncState *fs = ls->fs; 1172| 306| check_condition(ls, fs->f->is_vararg, ------------------ | | 122| 306|#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } | | ------------------ | | | Branch (122:41): [True: 0, False: 306] | | ------------------ ------------------ 1173| 306| "cannot use '...' outside a vararg function"); 1174| 306| init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 0, 1)); ------------------ | | 48| 306|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1175| 306| break; 1176| 306| } 1177| 340| case '{': { /* constructor */ ------------------ | Branch (1177:5): [True: 340, False: 7.41M] ------------------ 1178| 340| constructor(ls, v); 1179| 340| return; 1180| 306| } 1181| 99| case TK_FUNCTION: { ------------------ | Branch (1181:5): [True: 99, False: 7.41M] ------------------ 1182| 99| luaX_next(ls); 1183| 99| body(ls, v, 0, ls->linenumber); 1184| 99| return; 1185| 306| } 1186| 7.13M| default: { ------------------ | Branch (1186:5): [True: 7.13M, False: 282k] ------------------ 1187| 7.13M| suffixedexp(ls, v); 1188| 7.13M| return; 1189| 306| } 1190| 7.41M| } 1191| 282k| luaX_next(ls); 1192| 282k|} lparser.c:init_exp: 152| 14.3M|static void init_exp (expdesc *e, expkind k, int i) { 153| 14.3M| e->f = e->t = NO_JUMP; ------------------ | | 20| 14.3M|#define NO_JUMP (-1) ------------------ 154| 14.3M| e->k = k; 155| 14.3M| e->u.info = i; 156| 14.3M|} lparser.c:codestring: 159| 7.17M|static void codestring (expdesc *e, TString *s) { 160| 7.17M| e->f = e->t = NO_JUMP; ------------------ | | 20| 7.17M|#define NO_JUMP (-1) ------------------ 161| 7.17M| e->k = VKSTR; 162| 7.17M| e->u.strval = s; 163| 7.17M|} lparser.c:constructor: 925| 342|static void constructor (LexState *ls, expdesc *t) { 926| | /* constructor -> '{' [ field { sep field } [sep] ] '}' 927| | sep -> ',' | ';' */ 928| 342| FuncState *fs = ls->fs; 929| 342| int line = ls->linenumber; 930| 342| int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0); ------------------ | | 48| 342|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 931| 342| ConsControl cc; 932| 342| luaK_code(fs, 0); /* space for extra arg. */ 933| 342| cc.na = cc.nh = cc.tostore = 0; 934| 342| cc.t = t; 935| 342| init_exp(t, VNONRELOC, fs->freereg); /* table will be at stack top */ 936| 342| luaK_reserveregs(fs, 1); 937| 342| init_exp(&cc.v, VVOID, 0); /* no value (yet) */ 938| 342| checknext(ls, '{'); 939| 550| do { 940| 550| lua_assert(cc.v.k == VVOID || cc.tostore > 0); ------------------ | | 114| 550|#define lua_assert(c) ((void)0) ------------------ 941| 550| if (ls->t.token == '}') break; ------------------ | Branch (941:9): [True: 188, False: 362] ------------------ 942| 362| closelistfield(fs, &cc); 943| 362| field(ls, &cc); 944| 362| } while (testnext(ls, ',') || testnext(ls, ';')); ------------------ | Branch (944:12): [True: 124, False: 238] | Branch (944:33): [True: 84, False: 154] ------------------ 945| 0| check_match(ls, '}', '{', line); 946| 342| lastlistfield(fs, &cc); 947| 342| luaK_settablesize(fs, pc, t->u.info, cc.na, cc.nh); 948| 342|} lparser.c:closelistfield: 868| 362|static void closelistfield (FuncState *fs, ConsControl *cc) { 869| 362| if (cc->v.k == VVOID) return; /* there is no list item */ ------------------ | Branch (869:7): [True: 166, False: 196] ------------------ 870| 196| luaK_exp2nextreg(fs, &cc->v); 871| 196| cc->v.k = VVOID; 872| 196| if (cc->tostore == LFIELDS_PER_FLUSH) { ------------------ | | 403| 196|#define LFIELDS_PER_FLUSH 50 ------------------ | Branch (872:7): [True: 0, False: 196] ------------------ 873| 0| luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); /* flush */ 874| 0| cc->na += cc->tostore; 875| 0| cc->tostore = 0; /* no more items pending */ 876| 0| } 877| 196|} lparser.c:field: 903| 362|static void field (LexState *ls, ConsControl *cc) { 904| | /* field -> listfield | recfield */ 905| 362| switch(ls->t.token) { 906| 209| case TK_NAME: { /* may be 'listfield' or 'recfield' */ ------------------ | Branch (906:5): [True: 209, False: 153] ------------------ 907| 209| if (luaX_lookahead(ls) != '=') /* expression? */ ------------------ | Branch (907:11): [True: 195, False: 14] ------------------ 908| 195| listfield(ls, cc); 909| 14| else 910| 14| recfield(ls, cc); 911| 209| break; 912| 0| } 913| 0| case '[': { ------------------ | Branch (913:5): [True: 0, False: 362] ------------------ 914| 0| recfield(ls, cc); 915| 0| break; 916| 0| } 917| 153| default: { ------------------ | Branch (917:5): [True: 153, False: 209] ------------------ 918| 153| listfield(ls, cc); 919| 153| break; 920| 0| } 921| 362| } 922| 362|} lparser.c:listfield: 896| 348|static void listfield (LexState *ls, ConsControl *cc) { 897| | /* listfield -> exp */ 898| 348| expr(ls, &cc->v); 899| 348| cc->tostore++; 900| 348|} lparser.c:recfield: 847| 14|static void recfield (LexState *ls, ConsControl *cc) { 848| | /* recfield -> (NAME | '['exp']') = exp */ 849| 14| FuncState *fs = ls->fs; 850| 14| int reg = ls->fs->freereg; 851| 14| expdesc tab, key, val; 852| 14| if (ls->t.token == TK_NAME) { ------------------ | Branch (852:7): [True: 14, False: 0] ------------------ 853| 14| checklimit(fs, cc->nh, MAX_INT, "items in a constructor"); ------------------ | | 53| 14|#define MAX_INT INT_MAX /* maximum value of an int */ ------------------ 854| 14| codename(ls, &key); 855| 14| } 856| 0| else /* ls->t.token == '[' */ 857| 0| yindex(ls, &key); 858| 14| cc->nh++; 859| 14| checknext(ls, '='); 860| 14| tab = *cc->t; 861| 14| luaK_indexed(fs, &tab, &key); 862| 14| expr(ls, &val); 863| 14| luaK_storevar(fs, &tab, &val); 864| 14| fs->freereg = reg; /* free registers */ 865| 14|} lparser.c:codename: 166| 3.45k|static void codename (LexState *ls, expdesc *e) { 167| 3.45k| codestring(e, str_checkname(ls)); 168| 3.45k|} lparser.c:yindex: 822| 12.1k|static void yindex (LexState *ls, expdesc *v) { 823| | /* index -> '[' expr ']' */ 824| 12.1k| luaX_next(ls); /* skip the '[' */ 825| 12.1k| expr(ls, v); 826| 12.1k| luaK_exp2val(ls->fs, v); 827| 12.1k| checknext(ls, ']'); 828| 12.1k|} lparser.c:lastlistfield: 880| 341|static void lastlistfield (FuncState *fs, ConsControl *cc) { 881| 341| if (cc->tostore == 0) return; ------------------ | Branch (881:7): [True: 190, False: 151] ------------------ 882| 151| if (hasmultret(cc->v.k)) { ------------------ | | 38| 151|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 0, False: 151] | | | Branch (38:41): [True: 66, False: 85] | | ------------------ ------------------ 883| 66| luaK_setmultret(fs, &cc->v); ------------------ | | 58| 66|#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) | | ------------------ | | | | 36| 66|#define LUA_MULTRET (-1) | | ------------------ ------------------ 884| 66| luaK_setlist(fs, cc->t->u.info, cc->na, LUA_MULTRET); ------------------ | | 36| 66|#define LUA_MULTRET (-1) ------------------ 885| 66| cc->na--; /* do not count last expression (unknown number of elements) */ 886| 66| } 887| 85| else { 888| 85| if (cc->v.k != VVOID) ------------------ | Branch (888:9): [True: 85, False: 0] ------------------ 889| 85| luaK_exp2nextreg(fs, &cc->v); 890| 85| luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); 891| 85| } 892| 151| cc->na += cc->tostore; 893| 151|} lparser.c:body: 990| 4.23k|static void body (LexState *ls, expdesc *e, int ismethod, int line) { 991| | /* body -> '(' parlist ')' block END */ 992| 4.23k| FuncState new_fs; 993| 4.23k| BlockCnt bl; 994| 4.23k| new_fs.f = addprototype(ls); 995| 4.23k| new_fs.f->linedefined = line; 996| 4.23k| open_func(ls, &new_fs, &bl); 997| 4.23k| checknext(ls, '('); 998| 4.23k| if (ismethod) { ------------------ | Branch (998:7): [True: 8, False: 4.22k] ------------------ 999| 8| new_localvarliteral(ls, "self"); /* create 'self' parameter */ ------------------ | | 209| 8| new_localvar(ls, \ | | 210| 8| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1000| 8| adjustlocalvars(ls, 1); 1001| 8| } 1002| 4.23k| parlist(ls); 1003| 4.23k| checknext(ls, ')'); 1004| 4.23k| statlist(ls); 1005| 4.23k| new_fs.f->lastlinedefined = ls->linenumber; 1006| 4.23k| check_match(ls, TK_END, TK_FUNCTION, line); 1007| 4.23k| codeclosure(ls, e); 1008| 4.23k| close_func(ls); 1009| 4.23k|} lparser.c:addprototype: 698| 4.23k|static Proto *addprototype (LexState *ls) { 699| 4.23k| Proto *clp; 700| 4.23k| lua_State *L = ls->L; 701| 4.23k| FuncState *fs = ls->fs; 702| 4.23k| Proto *f = fs->f; /* prototype of current function */ 703| 4.23k| if (fs->np >= f->sizep) { ------------------ | Branch (703:7): [True: 1.09k, False: 3.14k] ------------------ 704| 1.09k| int oldsize = f->sizep; 705| 1.09k| luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions"); ------------------ | | 67| 1.09k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 2.18k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 1.09k| luaM_limitN(limit,t),e))) ------------------ 706| 8.09k| while (oldsize < f->sizep) ------------------ | Branch (706:12): [True: 7.00k, False: 1.09k] ------------------ 707| 7.00k| f->p[oldsize++] = NULL; 708| 1.09k| } 709| 4.23k| f->p[fs->np++] = clp = luaF_newproto(L); 710| 4.23k| luaC_objbarrier(L, f, clp); ------------------ | | 175| 4.23k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 4.23k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 4.23k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 4.23k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 8.47k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 4.23k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 4.23k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 4.23k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 4.23k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 711| 4.23k| return clp; 712| 4.23k|} lparser.c:new_localvar: 193| 6.95k|static int new_localvar (LexState *ls, TString *name) { 194| 6.95k| lua_State *L = ls->L; 195| 6.95k| FuncState *fs = ls->fs; 196| 6.95k| Dyndata *dyd = ls->dyd; 197| 6.95k| Vardesc *var; 198| 6.95k| checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal, 199| 6.95k| MAXVARS, "local variables"); ------------------ | | 35| 6.95k|#define MAXVARS 200 ------------------ 200| 6.95k| luaM_growvector(L, dyd->actvar.arr, dyd->actvar.n + 1, ------------------ | | 67| 6.95k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 13.9k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 6.95k| luaM_limitN(limit,t),e))) ------------------ 201| 6.95k| dyd->actvar.size, Vardesc, USHRT_MAX, "local variables"); 202| 6.95k| var = &dyd->actvar.arr[dyd->actvar.n++]; 203| 6.95k| var->vd.kind = VDKREG; /* default */ ------------------ | | 90| 6.95k|#define VDKREG 0 /* regular */ ------------------ 204| 6.95k| var->vd.name = name; 205| 6.95k| return dyd->actvar.n - 1 - fs->firstlocal; 206| 6.95k|} lparser.c:adjustlocalvars: 311| 8.84k|static void adjustlocalvars (LexState *ls, int nvars) { 312| 8.84k| FuncState *fs = ls->fs; 313| 8.84k| int reglevel = luaY_nvarstack(fs); 314| 8.84k| int i; 315| 14.6k| for (i = 0; i < nvars; i++) { ------------------ | Branch (315:15): [True: 5.78k, False: 8.84k] ------------------ 316| 5.78k| int vidx = fs->nactvar++; 317| 5.78k| Vardesc *var = getlocalvardesc(fs, vidx); 318| 5.78k| var->vd.ridx = reglevel++; 319| 5.78k| var->vd.pidx = registerlocalvar(ls, fs, var->vd.name); 320| 5.78k| } 321| 8.84k|} lparser.c:registerlocalvar: 175| 5.78k|static int registerlocalvar (LexState *ls, FuncState *fs, TString *varname) { 176| 5.78k| Proto *f = fs->f; 177| 5.78k| int oldsize = f->sizelocvars; 178| 5.78k| luaM_growvector(ls->L, f->locvars, fs->ndebugvars, f->sizelocvars, ------------------ | | 67| 5.78k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 11.5k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 5.78k| luaM_limitN(limit,t),e))) ------------------ 179| 5.78k| LocVar, SHRT_MAX, "local variables"); 180| 13.8k| while (oldsize < f->sizelocvars) ------------------ | Branch (180:10): [True: 8.10k, False: 5.78k] ------------------ 181| 8.10k| f->locvars[oldsize++].varname = NULL; 182| 5.78k| f->locvars[fs->ndebugvars].varname = varname; 183| 5.78k| f->locvars[fs->ndebugvars].startpc = fs->pc; 184| 5.78k| luaC_objbarrier(ls->L, f, varname); ------------------ | | 175| 5.78k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 5.78k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 5.78k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 5.78k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 11.5k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 5.78k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 5.78k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 5.78k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 5.78k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 185| 5.78k| return fs->ndebugvars++; 186| 5.78k|} lparser.c:parlist: 959| 4.23k|static void parlist (LexState *ls) { 960| | /* parlist -> [ {NAME ','} (NAME | '...') ] */ 961| 4.23k| FuncState *fs = ls->fs; 962| 4.23k| Proto *f = fs->f; 963| 4.23k| int nparams = 0; 964| 4.23k| int isvararg = 0; 965| 4.23k| if (ls->t.token != ')') { /* is 'parlist' not empty? */ ------------------ | Branch (965:7): [True: 246, False: 3.99k] ------------------ 966| 833| do { 967| 833| switch (ls->t.token) { 968| 781| case TK_NAME: { ------------------ | Branch (968:9): [True: 781, False: 52] ------------------ 969| 781| new_localvar(ls, str_checkname(ls)); 970| 781| nparams++; 971| 781| break; 972| 0| } 973| 52| case TK_DOTS: { ------------------ | Branch (973:9): [True: 52, False: 781] ------------------ 974| 52| luaX_next(ls); 975| 52| isvararg = 1; 976| 52| break; 977| 0| } 978| 0| default: luaX_syntaxerror(ls, " or '...' expected"); ------------------ | Branch (978:9): [True: 0, False: 833] ------------------ 979| 833| } 980| 833| } while (!isvararg && testnext(ls, ',')); ------------------ | Branch (980:14): [True: 781, False: 52] | Branch (980:27): [True: 587, False: 194] ------------------ 981| 246| } 982| 4.23k| adjustlocalvars(ls, nparams); 983| 4.23k| f->numparams = cast_byte(fs->nactvar); ------------------ | | 143| 4.23k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 4.23k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 984| 4.23k| if (isvararg) ------------------ | Branch (984:7): [True: 52, False: 4.18k] ------------------ 985| 52| setvararg(fs, f->numparams); /* declared vararg */ 986| 4.23k| luaK_reserveregs(fs, fs->nactvar); /* reserve registers for parameters */ 987| 4.23k|} lparser.c:codeclosure: 722| 3.89k|static void codeclosure (LexState *ls, expdesc *v) { 723| 3.89k| FuncState *fs = ls->fs->prev; 724| 3.89k| init_exp(v, VRELOC, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1)); 725| 3.89k| luaK_exp2nextreg(fs, v); /* fix it at the last register */ 726| 3.89k|} lparser.c:suffixedexp: 1102| 7.15M|static void suffixedexp (LexState *ls, expdesc *v) { 1103| | /* suffixedexp -> 1104| | primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */ 1105| 7.15M| FuncState *fs = ls->fs; 1106| 7.15M| int line = ls->linenumber; 1107| 7.15M| primaryexp(ls, v); 1108| 7.38M| for (;;) { 1109| 7.38M| switch (ls->t.token) { 1110| 3.20k| case '.': { /* fieldsel */ ------------------ | Branch (1110:7): [True: 3.20k, False: 7.38M] ------------------ 1111| 3.20k| fieldsel(ls, v); 1112| 3.20k| break; 1113| 0| } 1114| 12.1k| case '[': { /* '[' exp ']' */ ------------------ | Branch (1114:7): [True: 12.1k, False: 7.37M] ------------------ 1115| 12.1k| expdesc key; 1116| 12.1k| luaK_exp2anyregup(fs, v); 1117| 12.1k| yindex(ls, &key); 1118| 12.1k| luaK_indexed(fs, v, &key); 1119| 12.1k| break; 1120| 0| } 1121| 221| case ':': { /* ':' NAME funcargs */ ------------------ | Branch (1121:7): [True: 221, False: 7.38M] ------------------ 1122| 221| expdesc key; 1123| 221| luaX_next(ls); 1124| 221| codename(ls, &key); 1125| 221| luaK_self(fs, v, &key); 1126| 221| funcargs(ls, v, line); 1127| 221| break; 1128| 0| } 1129| 210k| case '(': case TK_STRING: case '{': { /* funcargs */ ------------------ | Branch (1129:7): [True: 20.1k, False: 7.36M] | Branch (1129:17): [True: 190k, False: 7.19M] | Branch (1129:33): [True: 2, False: 7.38M] ------------------ 1130| 210k| luaK_exp2nextreg(fs, v); 1131| 210k| funcargs(ls, v, line); 1132| 210k| break; 1133| 210k| } 1134| 7.15M| default: return; ------------------ | Branch (1134:7): [True: 7.15M, False: 225k] ------------------ 1135| 7.38M| } 1136| 7.38M| } 1137| 7.15M|} lparser.c:primaryexp: 1080| 7.15M|static void primaryexp (LexState *ls, expdesc *v) { 1081| | /* primaryexp -> NAME | '(' expr ')' */ 1082| 7.15M| switch (ls->t.token) { 1083| 37.8k| case '(': { ------------------ | Branch (1083:5): [True: 37.8k, False: 7.12M] ------------------ 1084| 37.8k| int line = ls->linenumber; 1085| 37.8k| luaX_next(ls); 1086| 37.8k| expr(ls, v); 1087| 37.8k| check_match(ls, ')', '(', line); 1088| 37.8k| luaK_dischargevars(ls->fs, v); 1089| 37.8k| return; 1090| 0| } 1091| 7.12M| case TK_NAME: { ------------------ | Branch (1091:5): [True: 7.12M, False: 37.8k] ------------------ 1092| 7.12M| singlevar(ls, v); 1093| 7.12M| return; 1094| 0| } 1095| 69| default: { ------------------ | Branch (1095:5): [True: 69, False: 7.15M] ------------------ 1096| 69| luaX_syntaxerror(ls, "unexpected symbol"); 1097| 0| } 1098| 7.15M| } 1099| 7.15M|} lparser.c:singlevar: 463| 7.12M|static void singlevar (LexState *ls, expdesc *var) { 464| 7.12M| TString *varname = str_checkname(ls); 465| 7.12M| FuncState *fs = ls->fs; 466| 7.12M| singlevaraux(fs, varname, var, 1); 467| 7.12M| if (var->k == VVOID) { /* global name? */ ------------------ | Branch (467:7): [True: 6.97M, False: 146k] ------------------ 468| 6.97M| expdesc key; 469| 6.97M| singlevaraux(fs, ls->envn, var, 1); /* get environment variable */ 470| 6.97M| lua_assert(var->k != VVOID); /* this one must exist */ ------------------ | | 114| 6.97M|#define lua_assert(c) ((void)0) ------------------ 471| 6.97M| luaK_exp2anyregup(fs, var); /* but could be a constant */ 472| 6.97M| codestring(&key, varname); /* key is variable name */ 473| 6.97M| luaK_indexed(fs, var, &key); /* env[varname] */ 474| 6.97M| } 475| 7.12M|} lparser.c:singlevaraux: 435| 22.7M|static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { 436| 22.7M| if (fs == NULL) /* no more levels? */ ------------------ | Branch (436:7): [True: 6.97M, False: 15.8M] ------------------ 437| 6.97M| init_exp(var, VVOID, 0); /* default is global */ 438| 15.8M| else { 439| 15.8M| int v = searchvar(fs, n, var); /* look up locals at current level */ 440| 15.8M| if (v >= 0) { /* found? */ ------------------ | Branch (440:9): [True: 1.13M, False: 14.6M] ------------------ 441| 1.13M| if (v == VLOCAL && !base) ------------------ | Branch (441:11): [True: 246k, False: 886k] | Branch (441:26): [True: 909, False: 245k] ------------------ 442| 909| markupval(fs, var->u.var.vidx); /* local will be used as an upval */ 443| 1.13M| } 444| 14.6M| else { /* not found as local at current level; try upvalues */ 445| 14.6M| int idx = searchupvalue(fs, n); /* try existing upvalues */ 446| 14.6M| if (idx < 0) { /* not found? */ ------------------ | Branch (446:11): [True: 8.68M, False: 5.99M] ------------------ 447| 8.68M| singlevaraux(fs->prev, n, var, 0); /* try upper levels */ 448| 8.68M| if (var->k == VLOCAL || var->k == VUPVAL) /* local or upvalue? */ ------------------ | Branch (448:13): [True: 909, False: 8.68M] | Branch (448:33): [True: 726, False: 8.68M] ------------------ 449| 1.63k| idx = newupvalue(fs, n, var); /* will be a new upvalue */ 450| 8.68M| else /* it is a global or a constant */ 451| 8.68M| return; /* don't need to do anything at this level */ 452| 8.68M| } 453| 5.99M| init_exp(var, VUPVAL, idx); /* new or old upvalue */ 454| 5.99M| } 455| 15.8M| } 456| 22.7M|} lparser.c:searchvar: 390| 15.8M|static int searchvar (FuncState *fs, TString *n, expdesc *var) { 391| 15.8M| int i; 392| 73.4M| for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) { ------------------ | | 141| 15.8M|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 15.8M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (392:39): [True: 58.7M, False: 14.6M] ------------------ 393| 58.7M| Vardesc *vd = getlocalvardesc(fs, i); 394| 58.7M| if (eqstr(n, vd->vd.name)) { /* found? */ ------------------ | | 43| 58.7M|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 1.13M, False: 57.6M] | | ------------------ ------------------ 395| 1.13M| if (vd->vd.kind == RDKCTC) /* compile-time constant? */ ------------------ | | 93| 1.13M|#define RDKCTC 3 /* compile-time constant */ ------------------ | Branch (395:11): [True: 886k, False: 246k] ------------------ 396| 886k| init_exp(var, VCONST, fs->firstlocal + i); 397| 246k| else /* real variable */ 398| 246k| init_var(fs, var, i); 399| 1.13M| return var->k; 400| 1.13M| } 401| 58.7M| } 402| 14.6M| return -1; /* not found */ 403| 15.8M|} lparser.c:init_var: 266| 246k|static void init_var (FuncState *fs, expdesc *e, int vidx) { 267| 246k| e->f = e->t = NO_JUMP; ------------------ | | 20| 246k|#define NO_JUMP (-1) ------------------ 268| 246k| e->k = VLOCAL; 269| 246k| e->u.var.vidx = vidx; 270| 246k| e->u.var.ridx = getlocalvardesc(fs, vidx)->vd.ridx; 271| 246k|} lparser.c:markupval: 410| 909|static void markupval (FuncState *fs, int level) { 411| 909| BlockCnt *bl = fs->bl; 412| 1.39k| while (bl->nactvar > level) ------------------ | Branch (412:10): [True: 486, False: 909] ------------------ 413| 486| bl = bl->previous; 414| 909| bl->upval = 1; 415| 909| fs->needclose = 1; 416| 909|} lparser.c:searchupvalue: 342| 14.6M|static int searchupvalue (FuncState *fs, TString *name) { 343| 14.6M| int i; 344| 14.6M| Upvaldesc *up = fs->f->upvalues; 345| 22.0M| for (i = 0; i < fs->nups; i++) { ------------------ | Branch (345:15): [True: 13.4M, False: 8.68M] ------------------ 346| 13.4M| if (eqstr(up[i].name, name)) return i; ------------------ | | 43| 13.4M|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 5.99M, False: 7.41M] | | ------------------ ------------------ 347| 13.4M| } 348| 8.68M| return -1; /* not found */ 349| 14.6M|} lparser.c:newupvalue: 364| 1.63k|static int newupvalue (FuncState *fs, TString *name, expdesc *v) { 365| 1.63k| Upvaldesc *up = allocupvalue(fs); 366| 1.63k| FuncState *prev = fs->prev; 367| 1.63k| if (v->k == VLOCAL) { ------------------ | Branch (367:7): [True: 909, False: 726] ------------------ 368| 909| up->instack = 1; 369| 909| up->idx = v->u.var.ridx; 370| 909| up->kind = getlocalvardesc(prev, v->u.var.vidx)->vd.kind; 371| 909| lua_assert(eqstr(name, getlocalvardesc(prev, v->u.var.vidx)->vd.name)); ------------------ | | 114| 909|#define lua_assert(c) ((void)0) ------------------ 372| 909| } 373| 726| else { 374| 726| up->instack = 0; 375| 726| up->idx = cast_byte(v->u.info); ------------------ | | 143| 726|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 726|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 376| 726| up->kind = prev->f->upvalues[v->u.info].kind; 377| 726| lua_assert(eqstr(name, prev->f->upvalues[v->u.info].name)); ------------------ | | 114| 726|#define lua_assert(c) ((void)0) ------------------ 378| 726| } 379| 1.63k| up->name = name; 380| 1.63k| luaC_objbarrier(fs->ls->L, fs->f, name); ------------------ | | 175| 1.63k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 1.63k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 1.63k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 1.63k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 3.27k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 1.63k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 1.63k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 1.63k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 1.63k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 381| 1.63k| return fs->nups - 1; 382| 1.63k|} lparser.c:fieldsel: 811| 3.22k|static void fieldsel (LexState *ls, expdesc *v) { 812| | /* fieldsel -> ['.' | ':'] NAME */ 813| 3.22k| FuncState *fs = ls->fs; 814| 3.22k| expdesc key; 815| 3.22k| luaK_exp2anyregup(fs, v); 816| 3.22k| luaX_next(ls); /* skip the dot or colon */ 817| 3.22k| codename(ls, &key); 818| 3.22k| luaK_indexed(fs, v, &key); 819| 3.22k|} lparser.c:funcargs: 1025| 210k|static void funcargs (LexState *ls, expdesc *f, int line) { 1026| 210k| FuncState *fs = ls->fs; 1027| 210k| expdesc args; 1028| 210k| int base, nparams; 1029| 210k| switch (ls->t.token) { 1030| 20.3k| case '(': { /* funcargs -> '(' [ explist ] ')' */ ------------------ | Branch (1030:5): [True: 20.3k, False: 190k] ------------------ 1031| 20.3k| luaX_next(ls); 1032| 20.3k| if (ls->t.token == ')') /* arg list is empty? */ ------------------ | Branch (1032:11): [True: 5.37k, False: 14.9k] ------------------ 1033| 5.37k| args.k = VVOID; 1034| 14.9k| else { 1035| 14.9k| explist(ls, &args); 1036| 14.9k| if (hasmultret(args.k)) ------------------ | | 38| 14.9k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 315, False: 14.6k] | | | Branch (38:41): [True: 18, False: 14.6k] | | ------------------ ------------------ 1037| 121| luaK_setmultret(fs, &args); ------------------ | | 58| 121|#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) | | ------------------ | | | | 36| 121|#define LUA_MULTRET (-1) | | ------------------ ------------------ 1038| 14.9k| } 1039| 20.3k| check_match(ls, ')', '(', line); 1040| 20.3k| break; 1041| 0| } 1042| 2| case '{': { /* funcargs -> constructor */ ------------------ | Branch (1042:5): [True: 2, False: 210k] ------------------ 1043| 2| constructor(ls, &args); 1044| 2| break; 1045| 0| } 1046| 190k| case TK_STRING: { /* funcargs -> STRING */ ------------------ | Branch (1046:5): [True: 190k, False: 20.3k] ------------------ 1047| 190k| codestring(&args, ls->t.seminfo.ts); 1048| 190k| luaX_next(ls); /* must use 'seminfo' before 'next' */ 1049| 190k| break; 1050| 0| } 1051| 1| default: { ------------------ | Branch (1051:5): [True: 1, False: 210k] ------------------ 1052| 1| luaX_syntaxerror(ls, "function arguments expected"); 1053| 0| } 1054| 210k| } 1055| 210k| lua_assert(f->k == VNONRELOC); ------------------ | | 114| 210k|#define lua_assert(c) ((void)0) ------------------ 1056| 210k| base = f->u.info; /* base register for call */ 1057| 210k| if (hasmultret(args.k)) ------------------ | | 38| 210k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 103, False: 210k] | | | Branch (38:41): [True: 18, False: 210k] | | ------------------ ------------------ 1058| 121| nparams = LUA_MULTRET; /* open call */ ------------------ | | 36| 121|#define LUA_MULTRET (-1) ------------------ 1059| 210k| else { 1060| 210k| if (args.k != VVOID) ------------------ | Branch (1060:9): [True: 204k, False: 5.37k] ------------------ 1061| 204k| luaK_exp2nextreg(fs, &args); /* close last argument */ 1062| 210k| nparams = fs->freereg - (base+1); 1063| 210k| } 1064| 210k| init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2)); ------------------ | | 48| 210k|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1065| 210k| luaK_fixline(fs, line); 1066| 210k| fs->freereg = base+1; /* call remove function and arguments and leaves 1067| | (unless changed) one result */ 1068| 210k|} lparser.c:explist: 1012| 40.5k|static int explist (LexState *ls, expdesc *v) { 1013| | /* explist -> expr { ',' expr } */ 1014| 40.5k| int n = 1; /* at least one expression */ 1015| 40.5k| expr(ls, v); 1016| 50.7k| while (testnext(ls, ',')) { ------------------ | Branch (1016:10): [True: 10.1k, False: 40.5k] ------------------ 1017| 10.1k| luaK_exp2nextreg(ls->fs, v); 1018| 10.1k| expr(ls, v); 1019| 10.1k| n++; 1020| 10.1k| } 1021| 40.5k| return n; 1022| 40.5k|} lparser.c:getbinopr: 1206| 7.61M|static BinOpr getbinopr (int op) { 1207| 7.61M| switch (op) { 1208| 4.17k| case '+': return OPR_ADD; ------------------ | Branch (1208:5): [True: 4.17k, False: 7.60M] ------------------ 1209| 40.9k| case '-': return OPR_SUB; ------------------ | Branch (1209:5): [True: 40.9k, False: 7.57M] ------------------ 1210| 42.0k| case '*': return OPR_MUL; ------------------ | Branch (1210:5): [True: 42.0k, False: 7.56M] ------------------ 1211| 18.4k| case '%': return OPR_MOD; ------------------ | Branch (1211:5): [True: 18.4k, False: 7.59M] ------------------ 1212| 304k| case '^': return OPR_POW; ------------------ | Branch (1212:5): [True: 304k, False: 7.30M] ------------------ 1213| 2.89M| case '/': return OPR_DIV; ------------------ | Branch (1213:5): [True: 2.89M, False: 4.71M] ------------------ 1214| 20.2k| case TK_IDIV: return OPR_IDIV; ------------------ | Branch (1214:5): [True: 20.2k, False: 7.59M] ------------------ 1215| 12.2k| case '&': return OPR_BAND; ------------------ | Branch (1215:5): [True: 12.2k, False: 7.59M] ------------------ 1216| 1.51k| case '|': return OPR_BOR; ------------------ | Branch (1216:5): [True: 1.51k, False: 7.60M] ------------------ 1217| 38.4k| case '~': return OPR_BXOR; ------------------ | Branch (1217:5): [True: 38.4k, False: 7.57M] ------------------ 1218| 251k| case TK_SHL: return OPR_SHL; ------------------ | Branch (1218:5): [True: 251k, False: 7.35M] ------------------ 1219| 2.04k| case TK_SHR: return OPR_SHR; ------------------ | Branch (1219:5): [True: 2.04k, False: 7.60M] ------------------ 1220| 10.4k| case TK_CONCAT: return OPR_CONCAT; ------------------ | Branch (1220:5): [True: 10.4k, False: 7.60M] ------------------ 1221| 2.75k| case TK_NE: return OPR_NE; ------------------ | Branch (1221:5): [True: 2.75k, False: 7.60M] ------------------ 1222| 1.51k| case TK_EQ: return OPR_EQ; ------------------ | Branch (1222:5): [True: 1.51k, False: 7.60M] ------------------ 1223| 3.66M| case '<': return OPR_LT; ------------------ | Branch (1223:5): [True: 3.66M, False: 3.94M] ------------------ 1224| 5.69k| case TK_LE: return OPR_LE; ------------------ | Branch (1224:5): [True: 5.69k, False: 7.60M] ------------------ 1225| 42.0k| case '>': return OPR_GT; ------------------ | Branch (1225:5): [True: 42.0k, False: 7.56M] ------------------ 1226| 608| case TK_GE: return OPR_GE; ------------------ | Branch (1226:5): [True: 608, False: 7.61M] ------------------ 1227| 20.2k| case TK_AND: return OPR_AND; ------------------ | Branch (1227:5): [True: 20.2k, False: 7.59M] ------------------ 1228| 117k| case TK_OR: return OPR_OR; ------------------ | Branch (1228:5): [True: 117k, False: 7.49M] ------------------ 1229| 113k| default: return OPR_NOBINOPR; ------------------ | Branch (1229:5): [True: 113k, False: 7.49M] ------------------ 1230| 7.61M| } 1231| 7.61M|} lparser.c:checknext: 116| 45.3k|static void checknext (LexState *ls, int c) { 117| 45.3k| check(ls, c); 118| 45.3k| luaX_next(ls); 119| 45.3k|} lparser.c:newgotoentry: 575| 2.84k|static int newgotoentry (LexState *ls, TString *name, int line, int pc) { 576| 2.84k| return newlabelentry(ls, &ls->dyd->gt, name, line, pc); 577| 2.84k|} lparser.c:newlabelentry: 561| 3.40k| int line, int pc) { 562| 3.40k| int n = l->n; 563| 3.40k| luaM_growvector(ls->L, l->arr, n, l->size, ------------------ | | 67| 3.40k| ((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \ | | ------------------ | | | | 136| 6.80k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [Folded - Ignored] | | | | ------------------ | | ------------------ | | 68| 3.40k| luaM_limitN(limit,t),e))) ------------------ 564| 3.40k| Labeldesc, SHRT_MAX, "labels/gotos"); 565| 3.40k| l->arr[n].name = name; 566| 3.40k| l->arr[n].line = line; 567| 3.40k| l->arr[n].nactvar = ls->fs->nactvar; 568| 3.40k| l->arr[n].close = 0; 569| 3.40k| l->arr[n].pc = pc; 570| 3.40k| l->n = n + 1; 571| 3.40k| return n; 572| 3.40k|} lparser.c:leaveblock: 672| 6.55k|static void leaveblock (FuncState *fs) { 673| 6.55k| BlockCnt *bl = fs->bl; 674| 6.55k| LexState *ls = fs->ls; 675| 6.55k| int hasclose = 0; 676| 6.55k| int stklevel = reglevel(fs, bl->nactvar); /* level outside the block */ 677| 6.55k| removevars(fs, bl->nactvar); /* remove block locals */ 678| 6.55k| lua_assert(bl->nactvar == fs->nactvar); /* back to level on entry */ ------------------ | | 114| 6.55k|#define lua_assert(c) ((void)0) ------------------ 679| 6.55k| if (bl->isloop) /* has to fix pending breaks? */ ------------------ | Branch (679:7): [True: 418, False: 6.14k] ------------------ 680| 418| hasclose = createlabel(ls, luaS_newliteral(ls->L, "break"), 0, 0); ------------------ | | 28| 418|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 418| (sizeof(s)/sizeof(char))-1)) ------------------ 681| 6.55k| if (!hasclose && bl->previous && bl->upval) /* still need a 'close'? */ ------------------ | Branch (681:7): [True: 6.55k, False: 0] | Branch (681:20): [True: 2.62k, False: 3.93k] | Branch (681:36): [True: 658, False: 1.96k] ------------------ 682| 658| luaK_codeABC(fs, OP_CLOSE, stklevel, 0, 0); ------------------ | | 48| 658|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 683| 6.55k| fs->freereg = stklevel; /* free registers */ 684| 6.55k| ls->dyd->label.n = bl->firstlabel; /* remove local labels */ 685| 6.55k| fs->bl = bl->previous; /* current block now is previous one */ 686| 6.55k| if (bl->previous) /* was it a nested block? */ ------------------ | Branch (686:7): [True: 2.62k, False: 3.93k] ------------------ 687| 2.62k| movegotosout(fs, bl); /* update pending gotos to enclosing block */ 688| 3.93k| else { 689| 3.93k| if (bl->firstgoto < ls->dyd->gt.n) /* still pending gotos? */ ------------------ | Branch (689:9): [True: 0, False: 3.93k] ------------------ 690| 0| undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */ 691| 3.93k| } 692| 6.55k|} lparser.c:removevars: 328| 6.55k|static void removevars (FuncState *fs, int tolevel) { 329| 6.55k| fs->ls->dyd->actvar.n -= (fs->nactvar - tolevel); 330| 10.0k| while (fs->nactvar > tolevel) { ------------------ | Branch (330:10): [True: 3.53k, False: 6.55k] ------------------ 331| 3.53k| LocVar *var = localdebuginfo(fs, --fs->nactvar); 332| 3.53k| if (var) /* does it have debug information? */ ------------------ | Branch (332:9): [True: 2.81k, False: 722] ------------------ 333| 2.81k| var->endpc = fs->pc; 334| 3.53k| } 335| 6.55k|} lparser.c:localdebuginfo: 251| 4.29k|static LocVar *localdebuginfo (FuncState *fs, int vidx) { 252| 4.29k| Vardesc *vd = getlocalvardesc(fs, vidx); 253| 4.29k| if (vd->vd.kind == RDKCTC) ------------------ | | 93| 4.29k|#define RDKCTC 3 /* compile-time constant */ ------------------ | Branch (253:7): [True: 722, False: 3.57k] ------------------ 254| 722| return NULL; /* no debug info. for constants */ 255| 3.57k| else { 256| 3.57k| int idx = vd->vd.pidx; 257| 3.57k| lua_assert(idx < fs->ndebugvars); ------------------ | | 114| 3.57k|#define lua_assert(c) ((void)0) ------------------ 258| 3.57k| return &fs->f->locvars[idx]; 259| 3.57k| } 260| 4.29k|} lparser.c:createlabel: 609| 564| int last) { 610| 564| FuncState *fs = ls->fs; 611| 564| Labellist *ll = &ls->dyd->label; 612| 564| int l = newlabelentry(ls, ll, name, line, luaK_getlabel(fs)); 613| 564| if (last) { /* label is last no-op statement in the block? */ ------------------ | Branch (613:7): [True: 0, False: 564] ------------------ 614| | /* assume that locals are already out of scope */ 615| 0| ll->arr[l].nactvar = fs->bl->nactvar; 616| 0| } 617| 564| if (solvegotos(ls, &ll->arr[l])) { /* need close? */ ------------------ | Branch (617:7): [True: 0, False: 564] ------------------ 618| 0| luaK_codeABC(fs, OP_CLOSE, luaY_nvarstack(fs), 0, 0); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 619| 0| return 1; 620| 0| } 621| 564| return 0; 622| 564|} lparser.c:solvegotos: 585| 564|static int solvegotos (LexState *ls, Labeldesc *lb) { 586| 564| Labellist *gl = &ls->dyd->gt; 587| 564| int i = ls->fs->bl->firstgoto; 588| 564| int needsclose = 0; 589| 916| while (i < gl->n) { ------------------ | Branch (589:10): [True: 352, False: 564] ------------------ 590| 352| if (eqstr(gl->arr[i].name, lb->name)) { ------------------ | | 43| 352|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 348, False: 4] | | ------------------ ------------------ 591| 348| needsclose |= gl->arr[i].close; 592| 348| solvegoto(ls, i, lb); /* will remove 'i' from the list */ 593| 348| } 594| 4| else 595| 4| i++; 596| 352| } 597| 564| return needsclose; 598| 564|} lparser.c:solvegoto: 527| 348|static void solvegoto (LexState *ls, int g, Labeldesc *label) { 528| 348| int i; 529| 348| Labellist *gl = &ls->dyd->gt; /* list of gotos */ 530| 348| Labeldesc *gt = &gl->arr[g]; /* goto to be resolved */ 531| 348| lua_assert(eqstr(gt->name, label->name)); ------------------ | | 114| 348|#define lua_assert(c) ((void)0) ------------------ 532| 348| if (l_unlikely(gt->nactvar < label->nactvar)) /* enter some scope? */ ------------------ | | 688| 348|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 348|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 1, False: 347] | | | | ------------------ | | ------------------ ------------------ 533| 1| jumpscopeerror(ls, gt); 534| 347| luaK_patchlist(ls->fs, gt->pc, label->pc); 535| 379| for (i = g; i < gl->n - 1; i++) /* remove goto from pending list */ ------------------ | Branch (535:15): [True: 32, False: 347] ------------------ 536| 32| gl->arr[i] = gl->arr[i + 1]; 537| 347| gl->n--; 538| 347|} lparser.c:jumpscopeerror: 514| 1|static l_noret jumpscopeerror (LexState *ls, Labeldesc *gt) { 515| 1| const char *varname = getstr(getlocalvardesc(ls->fs, gt->nactvar)->vd.name); ------------------ | | 403| 1|#define getstr(ts) ((ts)->contents) ------------------ 516| 1| const char *msg = " at line %d jumps into the scope of local '%s'"; 517| 1| msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line, varname); ------------------ | | 403| 1|#define getstr(ts) ((ts)->contents) ------------------ 518| 1| luaK_semerror(ls, msg); /* raise the error */ 519| 1|} lparser.c:movegotosout: 628| 2.62k|static void movegotosout (FuncState *fs, BlockCnt *bl) { 629| 2.62k| int i; 630| 2.62k| Labellist *gl = &fs->ls->dyd->gt; 631| | /* correct pending gotos to current block */ 632| 4.13k| for (i = bl->firstgoto; i < gl->n; i++) { /* for each pending goto */ ------------------ | Branch (632:27): [True: 1.51k, False: 2.62k] ------------------ 633| 1.51k| Labeldesc *gt = &gl->arr[i]; 634| | /* leaving a variable scope? */ 635| 1.51k| if (reglevel(fs, gt->nactvar) > reglevel(fs, bl->nactvar)) ------------------ | Branch (635:9): [True: 177, False: 1.33k] ------------------ 636| 177| gt->close |= bl->upval; /* jump may need a close */ 637| 1.51k| gt->nactvar = bl->nactvar; /* update goto level */ 638| 1.51k| } 639| 2.62k|} lparser.c:whilestat: 1468| 23|static void whilestat (LexState *ls, int line) { 1469| | /* whilestat -> WHILE cond DO block END */ 1470| 23| FuncState *fs = ls->fs; 1471| 23| int whileinit; 1472| 23| int condexit; 1473| 23| BlockCnt bl; 1474| 23| luaX_next(ls); /* skip WHILE */ 1475| 23| whileinit = luaK_getlabel(fs); 1476| 23| condexit = cond(ls); 1477| 23| enterblock(fs, &bl, 1); 1478| 23| checknext(ls, TK_DO); 1479| 23| block(ls); 1480| 23| luaK_jumpto(fs, whileinit); ------------------ | | 60| 23|#define luaK_jumpto(fs,t) luaK_patchlist(fs, luaK_jump(fs), t) ------------------ 1481| 23| check_match(ls, TK_END, TK_WHILE, line); 1482| 23| leaveblock(fs); 1483| 23| luaK_patchtohere(fs, condexit); /* false conditions finish the loop */ 1484| 23|} lparser.c:cond: 1406| 340|static int cond (LexState *ls) { 1407| | /* cond -> exp */ 1408| 340| expdesc v; 1409| 340| expr(ls, &v); /* read condition */ 1410| 340| if (v.k == VNIL) v.k = VFALSE; /* 'falses' are all equal here */ ------------------ | Branch (1410:7): [True: 266, False: 74] ------------------ 1411| 340| luaK_goiftrue(ls->fs, &v); 1412| 340| return v.f; 1413| 340|} lparser.c:block: 1305| 1.58k|static void block (LexState *ls) { 1306| | /* block -> statlist */ 1307| 1.58k| FuncState *fs = ls->fs; 1308| 1.58k| BlockCnt bl; 1309| 1.58k| enterblock(fs, &bl, 0); 1310| 1.58k| statlist(ls); 1311| 1.58k| leaveblock(fs); 1312| 1.58k|} lparser.c:check_match: 130| 61.9k|static void check_match (LexState *ls, int what, int who, int where) { 131| 61.9k| if (l_unlikely(!testnext(ls, what))) { ------------------ | | 688| 61.9k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 61.9k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 60, False: 61.9k] | | | | ------------------ | | ------------------ ------------------ 132| 60| if (where == ls->linenumber) /* all in the same line? */ ------------------ | Branch (132:9): [True: 33, False: 27] ------------------ 133| 33| error_expected(ls, what); /* do not need a complex message */ 134| 27| else { 135| 27| luaX_syntaxerror(ls, luaO_pushfstring(ls->L, 136| 27| "%s expected (to close %s at line %d)", 137| 27| luaX_token2str(ls, what), luaX_token2str(ls, who), where)); 138| 27| } 139| 60| } 140| 61.9k|} lparser.c:error_expected: 68| 37|static l_noret error_expected (LexState *ls, int token) { 69| 37| luaX_syntaxerror(ls, 70| 37| luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token))); 71| 37|} lparser.c:forstat: 1620| 447|static void forstat (LexState *ls, int line) { 1621| | /* forstat -> FOR (fornum | forlist) END */ 1622| 447| FuncState *fs = ls->fs; 1623| 447| TString *varname; 1624| 447| BlockCnt bl; 1625| 447| enterblock(fs, &bl, 1); /* scope for loop and control variables */ 1626| 447| luaX_next(ls); /* skip 'for' */ 1627| 447| varname = str_checkname(ls); /* first variable name */ 1628| 447| switch (ls->t.token) { 1629| 447| case '=': fornum(ls, varname, line); break; ------------------ | Branch (1629:5): [True: 447, False: 0] ------------------ 1630| 0| case ',': case TK_IN: forlist(ls, varname); break; ------------------ | Branch (1630:5): [True: 0, False: 447] | Branch (1630:15): [True: 0, False: 447] ------------------ 1631| 0| default: luaX_syntaxerror(ls, "'=' or 'in' expected"); ------------------ | Branch (1631:5): [True: 0, False: 447] ------------------ 1632| 447| } 1633| 88| check_match(ls, TK_END, TK_FOR, line); 1634| 88| leaveblock(fs); /* loop scope ('break' jumps to this point) */ 1635| 88|} lparser.c:fornum: 1569| 447|static void fornum (LexState *ls, TString *varname, int line) { 1570| | /* fornum -> NAME = exp,exp[,exp] forbody */ 1571| 447| FuncState *fs = ls->fs; 1572| 447| int base = fs->freereg; 1573| 447| new_localvarliteral(ls, "(for state)"); ------------------ | | 209| 447| new_localvar(ls, \ | | 210| 447| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1574| 447| new_localvarliteral(ls, "(for state)"); ------------------ | | 209| 447| new_localvar(ls, \ | | 210| 447| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1575| 447| new_localvarliteral(ls, "(for state)"); ------------------ | | 209| 447| new_localvar(ls, \ | | 210| 447| luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1)); ------------------ 1576| 447| new_localvar(ls, varname); 1577| 447| checknext(ls, '='); 1578| 447| exp1(ls); /* initial value */ 1579| 447| checknext(ls, ','); 1580| 447| exp1(ls); /* limit */ 1581| 447| if (testnext(ls, ',')) ------------------ | Branch (1581:7): [True: 1, False: 446] ------------------ 1582| 1| exp1(ls); /* optional step */ 1583| 446| else { /* default step = 1 */ 1584| 446| luaK_int(fs, fs->freereg, 1); 1585| 446| luaK_reserveregs(fs, 1); 1586| 446| } 1587| 447| adjustlocalvars(ls, 3); /* control variables */ 1588| 447| forbody(ls, base, line, 1, 0); 1589| 447|} lparser.c:exp1: 1517| 891|static void exp1 (LexState *ls) { 1518| 891| expdesc e; 1519| 891| expr(ls, &e); 1520| 891| luaK_exp2nextreg(ls->fs, &e); 1521| 891| lua_assert(e.k == VNONRELOC); ------------------ | | 114| 891|#define lua_assert(c) ((void)0) ------------------ 1522| 891|} lparser.c:forbody: 1544| 445|static void forbody (LexState *ls, int base, int line, int nvars, int isgen) { 1545| | /* forbody -> DO block */ 1546| 445| static const OpCode forprep[2] = {OP_FORPREP, OP_TFORPREP}; 1547| 445| static const OpCode forloop[2] = {OP_FORLOOP, OP_TFORLOOP}; 1548| 445| BlockCnt bl; 1549| 445| FuncState *fs = ls->fs; 1550| 445| int prep, endfor; 1551| 445| checknext(ls, TK_DO); 1552| 445| prep = luaK_codeABx(fs, forprep[isgen], base, 0); 1553| 445| enterblock(fs, &bl, 0); /* scope for declared variables */ 1554| 445| adjustlocalvars(ls, nvars); 1555| 445| luaK_reserveregs(fs, nvars); 1556| 445| block(ls); 1557| 445| leaveblock(fs); /* end of scope for declared variables */ 1558| 445| fixforjump(fs, prep, luaK_getlabel(fs), 0); 1559| 445| if (isgen) { /* generic for? */ ------------------ | Branch (1559:7): [True: 0, False: 445] ------------------ 1560| 0| luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1561| 0| luaK_fixline(fs, line); 1562| 0| } 1563| 445| endfor = luaK_codeABx(fs, forloop[isgen], base, 0); 1564| 445| fixforjump(fs, endfor, prep + 1, 1); 1565| 445| luaK_fixline(fs, line); 1566| 445|} lparser.c:fixforjump: 1530| 179|static void fixforjump (FuncState *fs, int pc, int dest, int back) { 1531| 179| Instruction *jmp = &fs->f->code[pc]; 1532| 179| int offset = dest - (pc + 1); 1533| 179| if (back) ------------------ | Branch (1533:7): [True: 89, False: 90] ------------------ 1534| 89| offset = -offset; 1535| 179| if (l_unlikely(offset > MAXARG_Bx)) ------------------ | | 688| 179|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 179|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 2, False: 177] | | | | ------------------ | | ------------------ ------------------ 1536| 2| luaX_syntaxerror(fs->ls, "control structure too long"); 1537| 177| SETARG_Bx(*jmp, offset); ------------------ | | 141| 177|#define SETARG_Bx(i,v) setarg(i, v, POS_Bx, SIZE_Bx) | | ------------------ | | | | 122| 177|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 177|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 177|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 177| ((cast(Instruction, v)<fs; 484| 8.45k| int needed = nvars - nexps; /* extra values needed */ 485| 8.45k| if (hasmultret(e->k)) { /* last expression has multiple returns? */ ------------------ | | 38| 8.45k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 1.21k, False: 7.24k] | | | Branch (38:41): [True: 69, False: 7.17k] | | ------------------ ------------------ 486| 1.28k| int extra = needed + 1; /* discount last expression itself */ 487| 1.28k| if (extra < 0) ------------------ | Branch (487:9): [True: 23, False: 1.26k] ------------------ 488| 23| extra = 0; 489| 1.28k| luaK_setreturns(fs, e, extra); /* last exp. provides the difference */ 490| 1.28k| } 491| 7.17k| else { 492| 7.17k| if (e->k != VVOID) /* at least one expression? */ ------------------ | Branch (492:9): [True: 6.84k, False: 332] ------------------ 493| 6.84k| luaK_exp2nextreg(fs, e); /* close last expression */ 494| 7.17k| if (needed > 0) /* missing values? */ ------------------ | Branch (494:9): [True: 672, False: 6.50k] ------------------ 495| 672| luaK_nil(fs, fs->freereg, needed); /* complete with nils */ 496| 7.17k| } 497| 8.45k| if (needed > 0) ------------------ | Branch (497:7): [True: 1.81k, False: 6.64k] ------------------ 498| 1.81k| luaK_reserveregs(fs, needed); /* registers for extra values */ 499| 6.64k| else /* adding 'needed' is actually a subtraction */ 500| 6.64k| fs->freereg += needed; /* remove extra values */ 501| 8.45k|} lparser.c:marktobeclosed: 422| 804|static void marktobeclosed (FuncState *fs) { 423| 804| BlockCnt *bl = fs->bl; 424| 804| bl->upval = 1; 425| 804| bl->insidetbc = 1; 426| 804| fs->needclose = 1; 427| 804|} lparser.c:repeatstat: 1487| 319|static void repeatstat (LexState *ls, int line) { 1488| | /* repeatstat -> REPEAT block UNTIL cond */ 1489| 319| int condexit; 1490| 319| FuncState *fs = ls->fs; 1491| 319| int repeat_init = luaK_getlabel(fs); 1492| 319| BlockCnt bl1, bl2; 1493| 319| enterblock(fs, &bl1, 1); /* loop block */ 1494| 319| enterblock(fs, &bl2, 0); /* scope block */ 1495| 319| luaX_next(ls); /* skip REPEAT */ 1496| 319| statlist(ls); 1497| 319| check_match(ls, TK_UNTIL, TK_REPEAT, line); 1498| 319| condexit = cond(ls); /* read condition (inside scope block) */ 1499| 319| leaveblock(fs); /* finish scope */ 1500| 319| if (bl2.upval) { /* upvalues? */ ------------------ | Branch (1500:7): [True: 0, False: 319] ------------------ 1501| 0| int exit = luaK_jump(fs); /* normal exit must jump over fix */ 1502| 0| luaK_patchtohere(fs, condexit); /* repetition must close upvalues */ 1503| 0| luaK_codeABC(fs, OP_CLOSE, reglevel(fs, bl2.nactvar), 0, 0); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1504| 0| condexit = luaK_jump(fs); /* repeat after closing upvalues */ 1505| 0| luaK_patchtohere(fs, exit); /* normal exit comes to here */ 1506| 0| } 1507| 319| luaK_patchlist(fs, condexit, repeat_init); /* close the loop */ 1508| 319| leaveblock(fs); /* finish loop */ 1509| 319|} lparser.c:funcstat: 1782| 3.21k|static void funcstat (LexState *ls, int line) { 1783| | /* funcstat -> FUNCTION funcname body */ 1784| 3.21k| int ismethod; 1785| 3.21k| expdesc v, b; 1786| 3.21k| luaX_next(ls); /* skip FUNCTION */ 1787| 3.21k| ismethod = funcname(ls, &v); 1788| 3.21k| body(ls, &b, ismethod, line); 1789| 3.21k| check_readonly(ls, &v); 1790| 3.21k| luaK_storevar(ls->fs, &v, &b); 1791| 3.21k| luaK_fixline(ls->fs, line); /* definition "happens" in the first line */ 1792| 3.21k|} lparser.c:funcname: 1768| 3.21k|static int funcname (LexState *ls, expdesc *v) { 1769| | /* funcname -> NAME {fieldsel} [':' NAME] */ 1770| 3.21k| int ismethod = 0; 1771| 3.21k| singlevar(ls, v); 1772| 3.22k| while (ls->t.token == '.') ------------------ | Branch (1772:10): [True: 12, False: 3.21k] ------------------ 1773| 12| fieldsel(ls, v); 1774| 3.21k| if (ls->t.token == ':') { ------------------ | Branch (1774:7): [True: 8, False: 3.20k] ------------------ 1775| 8| ismethod = 1; 1776| 8| fieldsel(ls, v); 1777| 8| } 1778| 3.21k| return ismethod; 1779| 3.21k|} lparser.c:check_readonly: 277| 27.5k|static void check_readonly (LexState *ls, expdesc *e) { 278| 27.5k| FuncState *fs = ls->fs; 279| 27.5k| TString *varname = NULL; /* to be set if variable is const */ 280| 27.5k| switch (e->k) { 281| 0| case VCONST: { ------------------ | Branch (281:5): [True: 0, False: 27.5k] ------------------ 282| 0| varname = ls->dyd->actvar.arr[e->u.info].vd.name; 283| 0| break; 284| 0| } 285| 4.67k| case VLOCAL: { ------------------ | Branch (285:5): [True: 4.67k, False: 22.8k] ------------------ 286| 4.67k| Vardesc *vardesc = getlocalvardesc(fs, e->u.var.vidx); 287| 4.67k| if (vardesc->vd.kind != VDKREG) /* not a regular variable? */ ------------------ | | 90| 4.67k|#define VDKREG 0 /* regular */ ------------------ | Branch (287:11): [True: 3, False: 4.66k] ------------------ 288| 3| varname = vardesc->vd.name; 289| 4.67k| break; 290| 0| } 291| 1.85k| case VUPVAL: { ------------------ | Branch (291:5): [True: 1.85k, False: 25.6k] ------------------ 292| 1.85k| Upvaldesc *up = &fs->f->upvalues[e->u.info]; 293| 1.85k| if (up->kind != VDKREG) ------------------ | | 90| 1.85k|#define VDKREG 0 /* regular */ ------------------ | Branch (293:11): [True: 0, False: 1.85k] ------------------ 294| 0| varname = up->name; 295| 1.85k| break; 296| 0| } 297| 21.0k| default: ------------------ | Branch (297:5): [True: 21.0k, False: 6.52k] ------------------ 298| 21.0k| return; /* other cases cannot be read-only */ 299| 27.5k| } 300| 6.52k| if (varname) { ------------------ | Branch (300:7): [True: 3, False: 6.52k] ------------------ 301| 3| const char *msg = luaO_pushfstring(ls->L, 302| 3| "attempt to assign to const variable '%s'", getstr(varname)); ------------------ | | 403| 3|#define getstr(ts) ((ts)->contents) ------------------ 303| 3| luaK_semerror(ls, msg); /* error */ 304| 3| } 305| 6.52k|} lparser.c:testnext: 95| 158k|static int testnext (LexState *ls, int c) { 96| 158k| if (ls->t.token == c) { ------------------ | Branch (96:7): [True: 88.6k, False: 69.5k] ------------------ 97| 88.6k| luaX_next(ls); 98| 88.6k| return 1; 99| 88.6k| } 100| 69.5k| else return 0; 101| 158k|} lparser.c:localfunc: 1689| 928|static void localfunc (LexState *ls) { 1690| 928| expdesc b; 1691| 928| FuncState *fs = ls->fs; 1692| 928| int fvar = fs->nactvar; /* function's variable index */ 1693| 928| new_localvar(ls, str_checkname(ls)); /* new local variable */ 1694| 928| adjustlocalvars(ls, 1); /* enter its scope */ 1695| 928| body(ls, &b, 0, ls->linenumber); /* function created in next register */ 1696| | /* debug information will only see the variable after this point! */ 1697| 928| localdebuginfo(fs, fvar)->startpc = fs->pc; 1698| 928|} lparser.c:localstat: 1726| 2.78k|static void localstat (LexState *ls) { 1727| | /* stat -> LOCAL NAME ATTRIB { ',' NAME ATTRIB } ['=' explist] */ 1728| 2.78k| FuncState *fs = ls->fs; 1729| 2.78k| int toclose = -1; /* index of to-be-closed variable (if any) */ 1730| 2.78k| Vardesc *var; /* last variable */ 1731| 2.78k| int vidx, kind; /* index and kind of last variable */ 1732| 2.78k| int nvars = 0; 1733| 2.78k| int nexps; 1734| 2.78k| expdesc e; 1735| 3.44k| do { 1736| 3.44k| vidx = new_localvar(ls, str_checkname(ls)); 1737| 3.44k| kind = getlocalattribute(ls); 1738| 3.44k| getlocalvardesc(fs, vidx)->vd.kind = kind; 1739| 3.44k| if (kind == RDKTOCLOSE) { /* to-be-closed? */ ------------------ | | 92| 3.44k|#define RDKTOCLOSE 2 /* to-be-closed */ ------------------ | Branch (1739:9): [True: 805, False: 2.64k] ------------------ 1740| 805| if (toclose != -1) /* one already present? */ ------------------ | Branch (1740:11): [True: 0, False: 805] ------------------ 1741| 0| luaK_semerror(ls, "multiple to-be-closed variables in local list"); 1742| 805| toclose = fs->nactvar + nvars; 1743| 805| } 1744| 3.44k| nvars++; 1745| 3.44k| } while (testnext(ls, ',')); ------------------ | Branch (1745:12): [True: 667, False: 2.78k] ------------------ 1746| 2.78k| if (testnext(ls, '=')) ------------------ | Branch (1746:7): [True: 2.44k, False: 332] ------------------ 1747| 2.44k| nexps = explist(ls, &e); 1748| 332| else { 1749| 332| e.k = VVOID; 1750| 332| nexps = 0; 1751| 332| } 1752| 2.78k| var = getlocalvardesc(fs, vidx); /* get last variable */ 1753| 2.78k| if (nvars == nexps && /* no adjustments? */ ------------------ | Branch (1753:7): [True: 1.57k, False: 1.20k] ------------------ 1754| 2.78k| var->vd.kind == RDKCONST && /* last variable is const? */ ------------------ | | 91| 4.35k|#define RDKCONST 1 /* constant */ ------------------ | Branch (1754:7): [True: 1.34k, False: 228] ------------------ 1755| 2.78k| luaK_exp2const(fs, &e, &var->k)) { /* compile-time constant? */ ------------------ | Branch (1755:7): [True: 1.16k, False: 188] ------------------ 1756| 1.16k| var->vd.kind = RDKCTC; /* variable is a compile-time constant */ ------------------ | | 93| 1.16k|#define RDKCTC 3 /* compile-time constant */ ------------------ 1757| 1.16k| adjustlocalvars(ls, nvars - 1); /* exclude last variable */ 1758| 1.16k| fs->nactvar++; /* but count it */ 1759| 1.16k| } 1760| 1.62k| else { 1761| 1.62k| adjust_assign(ls, nvars, nexps, &e); 1762| 1.62k| adjustlocalvars(ls, nvars); 1763| 1.62k| } 1764| 2.78k| checktoclose(fs, toclose); 1765| 2.78k|} lparser.c:getlocalattribute: 1701| 3.44k|static int getlocalattribute (LexState *ls) { 1702| | /* ATTRIB -> ['<' Name '>'] */ 1703| 3.44k| if (testnext(ls, '<')) { ------------------ | Branch (1703:7): [True: 2.24k, False: 1.20k] ------------------ 1704| 2.24k| const char *attr = getstr(str_checkname(ls)); ------------------ | | 403| 2.24k|#define getstr(ts) ((ts)->contents) ------------------ 1705| 2.24k| checknext(ls, '>'); 1706| 2.24k| if (strcmp(attr, "const") == 0) ------------------ | Branch (1706:9): [True: 1.43k, False: 805] ------------------ 1707| 1.43k| return RDKCONST; /* read-only variable */ ------------------ | | 91| 1.43k|#define RDKCONST 1 /* constant */ ------------------ 1708| 805| else if (strcmp(attr, "close") == 0) ------------------ | Branch (1708:14): [True: 805, False: 0] ------------------ 1709| 805| return RDKTOCLOSE; /* to-be-closed variable */ ------------------ | | 92| 805|#define RDKTOCLOSE 2 /* to-be-closed */ ------------------ 1710| 0| else 1711| 0| luaK_semerror(ls, 1712| 0| luaO_pushfstring(ls->L, "unknown attribute '%s'", attr)); 1713| 2.24k| } 1714| 1.20k| return VDKREG; /* regular variable */ ------------------ | | 90| 1.20k|#define VDKREG 0 /* regular */ ------------------ 1715| 3.44k|} lparser.c:checktoclose: 1718| 2.77k|static void checktoclose (FuncState *fs, int level) { 1719| 2.77k| if (level != -1) { /* is there a to-be-closed variable? */ ------------------ | Branch (1719:7): [True: 804, False: 1.97k] ------------------ 1720| 804| marktobeclosed(fs); 1721| 804| luaK_codeABC(fs, OP_TBC, reglevel(fs, level), 0, 0); ------------------ | | 48| 804|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1722| 804| } 1723| 2.77k|} lparser.c:labelstat: 1458| 146|static void labelstat (LexState *ls, TString *name, int line) { 1459| | /* label -> '::' NAME '::' */ 1460| 146| checknext(ls, TK_DBCOLON); /* skip double colon */ 1461| 459| while (ls->t.token == ';' || ls->t.token == TK_DBCOLON) ------------------ | Branch (1461:10): [True: 217, False: 242] | Branch (1461:32): [True: 96, False: 146] ------------------ 1462| 313| statement(ls); /* skip other no-op statements */ 1463| 146| checkrepeated(ls, name); /* check for repeated labels */ 1464| 146| createlabel(ls, name, line, block_follow(ls, 0)); 1465| 146|} lparser.c:checkrepeated: 1448| 146|static void checkrepeated (LexState *ls, TString *name) { 1449| 146| Labeldesc *lb = findlabel(ls, name); 1450| 146| if (l_unlikely(lb != NULL)) { /* already defined? */ ------------------ | | 688| 146|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 146|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 146] | | | | ------------------ | | ------------------ ------------------ 1451| 0| const char *msg = "label '%s' already defined on line %d"; 1452| 0| msg = luaO_pushfstring(ls->L, msg, getstr(name), lb->line); ------------------ | | 403| 0|#define getstr(ts) ((ts)->contents) ------------------ 1453| 0| luaK_semerror(ls, msg); /* error */ 1454| 0| } 1455| 146|} lparser.c:findlabel: 544| 1.43k|static Labeldesc *findlabel (LexState *ls, TString *name) { 545| 1.43k| int i; 546| 1.43k| Dyndata *dyd = ls->dyd; 547| | /* check labels in current function for a match */ 548| 2.12k| for (i = ls->fs->firstlabel; i < dyd->label.n; i++) { ------------------ | Branch (548:32): [True: 688, False: 1.43k] ------------------ 549| 688| Labeldesc *lb = &dyd->label.arr[i]; 550| 688| if (eqstr(lb->name, name)) /* correct label? */ ------------------ | | 43| 688|#define eqstr(a,b) ((a) == (b)) | | ------------------ | | | Branch (43:20): [True: 0, False: 688] | | ------------------ ------------------ 551| 0| return lb; 552| 688| } 553| 1.43k| return NULL; /* label not found */ 554| 1.43k|} lparser.c:str_checkname: 143| 7.13M|static TString *str_checkname (LexState *ls) { 144| 7.13M| TString *ts; 145| 7.13M| check(ls, TK_NAME); 146| 7.13M| ts = ls->t.seminfo.ts; 147| 7.13M| luaX_next(ls); 148| 7.13M| return ts; 149| 7.13M|} lparser.c:retstat: 1813| 3.71k|static void retstat (LexState *ls) { 1814| | /* stat -> RETURN [explist] [';'] */ 1815| 3.71k| FuncState *fs = ls->fs; 1816| 3.71k| expdesc e; 1817| 3.71k| int nret; /* number of values being returned */ 1818| 3.71k| int first = luaY_nvarstack(fs); /* first slot to be returned */ 1819| 3.71k| if (block_follow(ls, 1) || ls->t.token == ';') ------------------ | Branch (1819:7): [True: 20, False: 3.69k] | Branch (1819:30): [True: 141, False: 3.55k] ------------------ 1820| 161| nret = 0; /* return no values */ 1821| 3.55k| else { 1822| 3.55k| nret = explist(ls, &e); /* optional return values */ 1823| 3.55k| if (hasmultret(e.k)) { ------------------ | | 38| 3.55k|#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) | | ------------------ | | | Branch (38:25): [True: 23, False: 3.53k] | | | Branch (38:41): [True: 7, False: 3.52k] | | ------------------ ------------------ 1824| 29| luaK_setmultret(fs, &e); ------------------ | | 58| 29|#define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) | | ------------------ | | | | 36| 29|#define LUA_MULTRET (-1) | | ------------------ ------------------ 1825| 29| if (e.k == VCALL && nret == 1 && !fs->bl->insidetbc) { /* tail call? */ ------------------ | Branch (1825:11): [True: 22, False: 7] | Branch (1825:27): [True: 22, False: 0] | Branch (1825:40): [True: 16, False: 6] ------------------ 1826| 16| SET_OPCODE(getinstruction(fs,&e), OP_TAILCALL); ------------------ | | 115| 16|#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \ | | ------------------ | | | | 108| 16|#define MASK0(n,p) (~MASK1(n,p)) | | | | ------------------ | | | | | | 105| 16|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | ------------------ | | ------------------ | | 116| 16| ((cast(Instruction, o)<freereg - first); ------------------ | | 114| 50|#define lua_assert(c) ((void)0) ------------------ 1837| 50| } 1838| 3.52k| } 1839| 3.55k| } 1840| 3.71k| luaK_ret(fs, first, nret); 1841| 3.71k| testnext(ls, ';'); /* skip optional semicolon */ 1842| 3.71k|} lparser.c:breakstat: 1438| 754|static void breakstat (LexState *ls) { 1439| 754| int line = ls->linenumber; 1440| 754| luaX_next(ls); /* skip break */ 1441| 754| newgotoentry(ls, luaS_newliteral(ls->L, "break"), line, luaK_jump(ls->fs)); ------------------ | | 28| 754|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 754| (sizeof(s)/sizeof(char))-1)) ------------------ 1442| 754|} lparser.c:gotostat: 1416| 1.28k|static void gotostat (LexState *ls) { 1417| 1.28k| FuncState *fs = ls->fs; 1418| 1.28k| int line = ls->linenumber; 1419| 1.28k| TString *name = str_checkname(ls); /* label's name */ 1420| 1.28k| Labeldesc *lb = findlabel(ls, name); 1421| 1.28k| if (lb == NULL) /* no label? */ ------------------ | Branch (1421:7): [True: 1.28k, False: 0] ------------------ 1422| | /* forward jump; will be resolved when the label is declared */ 1423| 1.28k| newgotoentry(ls, name, line, luaK_jump(fs)); 1424| 0| else { /* found a label */ 1425| | /* backward jump; will be resolved here */ 1426| 0| int lblevel = reglevel(fs, lb->nactvar); /* label level */ 1427| 0| if (luaY_nvarstack(fs) > lblevel) /* leaving the scope of a variable? */ ------------------ | Branch (1427:9): [True: 0, False: 0] ------------------ 1428| 0| luaK_codeABC(fs, OP_CLOSE, lblevel, 0, 0); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1429| | /* create jump and link it to the label */ 1430| 0| luaK_patchlist(fs, luaK_jump(fs), lb->pc); 1431| 0| } 1432| 1.28k|} lparser.c:exprstat: 1795| 21.2k|static void exprstat (LexState *ls) { 1796| | /* stat -> func | assignment */ 1797| 21.2k| FuncState *fs = ls->fs; 1798| 21.2k| struct LHS_assign v; 1799| 21.2k| suffixedexp(ls, &v.v); 1800| 21.2k| if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */ ------------------ | Branch (1800:7): [True: 18.0k, False: 3.14k] | Branch (1800:29): [True: 1.64k, False: 1.49k] ------------------ 1801| 19.6k| v.prev = NULL; 1802| 19.6k| restassign(ls, &v, 1); 1803| 19.6k| } 1804| 1.55k| else { /* stat -> func */ 1805| 1.55k| Instruction *inst; 1806| 1.55k| check_condition(ls, v.v.k == VCALL, "syntax error"); ------------------ | | 122| 1.55k|#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } | | ------------------ | | | Branch (122:41): [True: 17, False: 1.53k] | | ------------------ ------------------ 1807| 1.53k| inst = &getinstruction(fs, &v.v); ------------------ | | 55| 1.53k|#define getinstruction(fs,e) ((fs)->f->code[(e)->u.info]) ------------------ 1808| 1.53k| SETARG_C(*inst, 1); /* call statement uses no results */ ------------------ | | 134| 1.53k|#define SETARG_C(i,v) setarg(i, v, POS_C, SIZE_C) | | ------------------ | | | | 122| 1.53k|#define setarg(i,v,pos,size) ((i) = (((i)&MASK0(size,pos)) | \ | | | | ------------------ | | | | | | 108| 1.53k|#define MASK0(n,p) (~MASK1(n,p)) | | | | | | ------------------ | | | | | | | | 105| 1.53k|#define MASK1(n,p) ((~((~(Instruction)0)<<(n)))<<(p)) | | | | | | ------------------ | | | | ------------------ | | | | 123| 1.53k| ((cast(Instruction, v)<v.k), "syntax error"); ------------------ | | 122| 49.0k|#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } | | ------------------ | | | Branch (122:43): [True: 24.5k, False: 0] | | | Branch (122:43): [True: 24.5k, False: 0] | | ------------------ ------------------ 1378| 24.5k| check_readonly(ls, &lh->v); 1379| 24.5k| if (testnext(ls, ',')) { /* restassign -> ',' suffixedexp restassign */ ------------------ | Branch (1379:7): [True: 4.85k, False: 19.6k] ------------------ 1380| 4.85k| struct LHS_assign nv; 1381| 4.85k| nv.prev = lh; 1382| 4.85k| suffixedexp(ls, &nv.v); 1383| 4.85k| if (!vkisindexed(nv.v.k)) ------------------ | | 65| 4.85k|#define vkisindexed(k) (VINDEXED <= (k) && (k) <= VINDEXSTR) | | ------------------ | | | Branch (65:25): [True: 4.47k, False: 377] | | | Branch (65:44): [True: 4.47k, False: 0] | | ------------------ ------------------ 1384| 376| check_conflict(ls, lh, &nv.v); 1385| 4.85k| enterlevel(ls); /* control recursion depth */ ------------------ | | 504| 4.85k|#define enterlevel(ls) luaE_incCstack(ls->L) ------------------ 1386| 4.85k| restassign(ls, &nv, nvars+1); 1387| 4.85k| leavelevel(ls); ------------------ | | 507| 4.85k|#define leavelevel(ls) ((ls)->L->nCcalls--) ------------------ 1388| 4.85k| } 1389| 19.6k| else { /* restassign -> '=' explist */ 1390| 19.6k| int nexps; 1391| 19.6k| checknext(ls, '='); 1392| 19.6k| nexps = explist(ls, &e); 1393| 19.6k| if (nexps != nvars) ------------------ | Branch (1393:9): [True: 6.83k, False: 12.8k] ------------------ 1394| 6.83k| adjust_assign(ls, nvars, nexps, &e); 1395| 12.8k| else { 1396| 12.8k| luaK_setoneret(ls->fs, &e); /* close last expression */ 1397| 12.8k| luaK_storevar(ls->fs, &lh->v, &e); 1398| 12.8k| return; /* avoid default */ 1399| 12.8k| } 1400| 19.6k| } 1401| 11.6k| init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */ 1402| 11.6k| luaK_storevar(ls->fs, &lh->v, &e); 1403| 11.6k|} lparser.c:check_conflict: 1331| 376|static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) { 1332| 376| FuncState *fs = ls->fs; 1333| 376| int extra = fs->freereg; /* eventual position to save local variable */ 1334| 376| int conflict = 0; 1335| 10.4k| for (; lh; lh = lh->prev) { /* check all previous assignments */ ------------------ | Branch (1335:10): [True: 10.0k, False: 376] ------------------ 1336| 10.0k| if (vkisindexed(lh->v.k)) { /* assignment to table field? */ ------------------ | | 65| 10.0k|#define vkisindexed(k) (VINDEXED <= (k) && (k) <= VINDEXSTR) | | ------------------ | | | Branch (65:25): [True: 6.35k, False: 3.74k] | | | Branch (65:44): [True: 6.35k, False: 0] | | ------------------ ------------------ 1337| 6.35k| if (lh->v.k == VINDEXUP) { /* is table an upvalue? */ ------------------ | Branch (1337:11): [True: 6.29k, False: 64] ------------------ 1338| 6.29k| if (v->k == VUPVAL && lh->v.u.ind.t == v->u.info) { ------------------ | Branch (1338:13): [True: 98, False: 6.19k] | Branch (1338:31): [True: 0, False: 98] ------------------ 1339| 0| conflict = 1; /* table is the upvalue being assigned now */ 1340| 0| lh->v.k = VINDEXSTR; 1341| 0| lh->v.u.ind.t = extra; /* assignment will use safe copy */ 1342| 0| } 1343| 6.29k| } 1344| 64| else { /* table is a register */ 1345| 64| if (v->k == VLOCAL && lh->v.u.ind.t == v->u.var.ridx) { ------------------ | Branch (1345:13): [True: 64, False: 0] | Branch (1345:31): [True: 0, False: 64] ------------------ 1346| 0| conflict = 1; /* table is the local being assigned now */ 1347| 0| lh->v.u.ind.t = extra; /* assignment will use safe copy */ 1348| 0| } 1349| | /* is index the local being assigned? */ 1350| 64| if (lh->v.k == VINDEXED && v->k == VLOCAL && ------------------ | Branch (1350:13): [True: 0, False: 64] | Branch (1350:36): [True: 0, False: 0] ------------------ 1351| 64| lh->v.u.ind.idx == v->u.var.ridx) { ------------------ | Branch (1351:13): [True: 0, False: 0] ------------------ 1352| 0| conflict = 1; 1353| 0| lh->v.u.ind.idx = extra; /* previous assignment will use safe copy */ 1354| 0| } 1355| 64| } 1356| 6.35k| } 1357| 10.0k| } 1358| 376| if (conflict) { ------------------ | Branch (1358:7): [True: 0, False: 376] ------------------ 1359| | /* copy upvalue/local value to a temporary (in position 'extra') */ 1360| 0| if (v->k == VLOCAL) ------------------ | Branch (1360:9): [True: 0, False: 0] ------------------ 1361| 0| luaK_codeABC(fs, OP_MOVE, extra, v->u.var.ridx, 0); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1362| 0| else 1363| 0| luaK_codeABC(fs, OP_GETUPVAL, extra, v->u.info, 0); ------------------ | | 48| 0|#define luaK_codeABC(fs,o,a,b,c) luaK_codeABCk(fs,o,a,b,c,0) ------------------ 1364| 0| luaK_reserveregs(fs, 1); 1365| 0| } 1366| 376|} lparser.c:check: 107| 7.18M|static void check (LexState *ls, int c) { 108| 7.18M| if (ls->t.token != c) ------------------ | Branch (108:7): [True: 4, False: 7.18M] ------------------ 109| 4| error_expected(ls, c); 110| 7.18M|} lparser.c:close_func: 756| 3.93k|static void close_func (LexState *ls) { 757| 3.93k| lua_State *L = ls->L; 758| 3.93k| FuncState *fs = ls->fs; 759| 3.93k| Proto *f = fs->f; 760| 3.93k| luaK_ret(fs, luaY_nvarstack(fs), 0); /* final return */ 761| 3.93k| leaveblock(fs); 762| 3.93k| lua_assert(fs->bl == NULL); ------------------ | | 114| 3.93k|#define lua_assert(c) ((void)0) ------------------ 763| 3.93k| luaK_finish(fs); 764| 3.93k| luaM_shrinkvector(L, f->code, f->sizecode, fs->pc, Instruction); ------------------ | | 75| 3.93k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 3.93k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 765| 3.93k| luaM_shrinkvector(L, f->lineinfo, f->sizelineinfo, fs->pc, ls_byte); ------------------ | | 75| 3.93k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 3.93k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 766| 3.93k| luaM_shrinkvector(L, f->abslineinfo, f->sizeabslineinfo, ------------------ | | 75| 3.93k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 3.93k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 767| 3.93k| fs->nabslineinfo, AbsLineInfo); 768| 3.93k| luaM_shrinkvector(L, f->k, f->sizek, fs->nk, TValue); ------------------ | | 75| 3.93k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 3.93k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 769| 3.93k| luaM_shrinkvector(L, f->p, f->sizep, fs->np, Proto *); ------------------ | | 75| 3.93k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 3.93k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 770| 3.93k| luaM_shrinkvector(L, f->locvars, f->sizelocvars, fs->ndebugvars, LocVar); ------------------ | | 75| 3.93k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 3.93k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 771| 3.93k| luaM_shrinkvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc); ------------------ | | 75| 3.93k| ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t)))) | | ------------------ | | | | 136| 3.93k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 772| 3.93k| ls->fs = fs->prev; 773| 3.93k| luaC_checkGC(L); ------------------ | | 172| 3.93k|#define luaC_checkGC(L) luaC_condGC(L,(void)0,(void)0) | | ------------------ | | | | 168| 3.93k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 3.93k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 41, False: 3.89k] | | | | ------------------ | | | | 169| 3.93k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 3.93k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 774| 3.93k|} luaE_setdebt: 89| 1.01k|void luaE_setdebt (global_State *g, l_mem debt) { 90| 1.01k| l_mem tb = gettotalbytes(g); ------------------ | | 394| 1.01k|#define gettotalbytes(g) cast(lu_mem, (g)->totalbytes + (g)->GCdebt) | | ------------------ | | | | 136| 1.01k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 91| 1.01k| lua_assert(tb > 0); ------------------ | | 114| 1.01k|#define lua_assert(c) ((void)0) ------------------ 92| 1.01k| if (debt < tb - MAX_LMEM) ------------------ | | 50| 1.01k|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 1.01k|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ | Branch (92:7): [True: 0, False: 1.01k] ------------------ 93| 0| debt = tb - MAX_LMEM; /* will make 'totalbytes == MAX_LMEM' */ ------------------ | | 50| 0|#define MAX_LMEM ((l_mem)(MAX_LUMEM >> 1)) | | ------------------ | | | | 48| 0|#define MAX_LUMEM ((lu_mem)(~(lu_mem)0)) | | ------------------ ------------------ 94| 1.01k| g->totalbytes = tb - debt; 95| 1.01k| g->GCdebt = debt; 96| 1.01k|} luaE_extendCI: 105| 1.39k|CallInfo *luaE_extendCI (lua_State *L) { 106| 1.39k| CallInfo *ci; 107| 1.39k| lua_assert(L->ci->next == NULL); ------------------ | | 114| 1.39k|#define lua_assert(c) ((void)0) ------------------ 108| 1.39k| ci = luaM_new(L, CallInfo); ------------------ | | 59| 1.39k|#define luaM_new(L,t) cast(t*, luaM_malloc_(L, sizeof(t), 0)) | | ------------------ | | | | 136| 1.39k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 109| 1.39k| lua_assert(L->ci->next == NULL); ------------------ | | 114| 1.39k|#define lua_assert(c) ((void)0) ------------------ 110| 1.39k| L->ci->next = ci; 111| 1.39k| ci->previous = L->ci; 112| 1.39k| ci->next = NULL; 113| 1.39k| ci->u.l.trap = 0; 114| 1.39k| L->nci++; 115| 1.39k| return ci; 116| 1.39k|} luaE_freeCI: 122| 258|void luaE_freeCI (lua_State *L) { 123| 258| CallInfo *ci = L->ci; 124| 258| CallInfo *next = ci->next; 125| 258| ci->next = NULL; 126| 963| while ((ci = next) != NULL) { ------------------ | Branch (126:10): [True: 705, False: 258] ------------------ 127| 705| next = ci->next; 128| 705| luaM_free(L, ci); ------------------ | | 56| 705|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 129| 705| L->nci--; 130| 705| } 131| 258|} luaE_shrinkCI: 138| 1.26k|void luaE_shrinkCI (lua_State *L) { 139| 1.26k| CallInfo *ci = L->ci->next; /* first free CallInfo */ 140| 1.26k| CallInfo *next; 141| 1.26k| if (ci == NULL) ------------------ | Branch (141:7): [True: 1.20k, False: 57] ------------------ 142| 1.20k| return; /* no extra elements */ 143| 722| while ((next = ci->next) != NULL) { /* two extra elements? */ ------------------ | Branch (143:10): [True: 692, False: 30] ------------------ 144| 692| CallInfo *next2 = next->next; /* next's next */ 145| 692| ci->next = next2; /* remove next from the list */ 146| 692| L->nci--; 147| 692| luaM_free(L, next); /* free next */ ------------------ | | 56| 692|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 148| 692| if (next2 == NULL) ------------------ | Branch (148:9): [True: 27, False: 665] ------------------ 149| 27| break; /* no more elements */ 150| 665| else { 151| 665| next2->previous = ci; 152| 665| ci = next2; /* continue */ 153| 665| } 154| 692| } 155| 57|} luaE_checkcstack: 165| 2|void luaE_checkcstack (lua_State *L) { 166| 2| if (getCcalls(L) == LUAI_MAXCCALLS) ------------------ | | 107| 2|#define getCcalls(L) ((L)->nCcalls & 0xffff) ------------------ if (getCcalls(L) == LUAI_MAXCCALLS) ------------------ | | 255| 2|#define LUAI_MAXCCALLS 200 ------------------ | Branch (166:7): [True: 2, False: 0] ------------------ 167| 2| luaG_runerror(L, "C stack overflow"); 168| 0| else if (getCcalls(L) >= (LUAI_MAXCCALLS / 10 * 11)) ------------------ | | 107| 0|#define getCcalls(L) ((L)->nCcalls & 0xffff) ------------------ else if (getCcalls(L) >= (LUAI_MAXCCALLS / 10 * 11)) ------------------ | | 255| 0|#define LUAI_MAXCCALLS 200 ------------------ | Branch (168:12): [True: 0, False: 0] ------------------ 169| 0| luaD_throw(L, LUA_ERRERR); /* error while handling stack error */ ------------------ | | 54| 0|#define LUA_ERRERR 5 ------------------ 170| 2|} luaE_incCstack: 173| 7.66M|LUAI_FUNC void luaE_incCstack (lua_State *L) { 174| 7.66M| L->nCcalls++; 175| 7.66M| if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) ------------------ | | 688| 7.66M|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 7.66M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 2, False: 7.66M] | | | | ------------------ | | ------------------ ------------------ 176| 2| luaE_checkcstack(L); 177| 7.66M|} lua_newstate: 352| 258|LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) { 353| 258| int i; 354| 258| lua_State *L; 355| 258| global_State *g; 356| 258| LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG))); ------------------ | | 136| 258|#define cast(t, exp) ((t)(exp)) ------------------ 357| 258| if (l == NULL) return NULL; ------------------ | Branch (357:7): [True: 0, False: 258] ------------------ 358| 258| L = &l->l.l; 359| 258| g = &l->g; 360| 258| L->tt = LUA_VTHREAD; ------------------ | | 262| 258|#define LUA_VTHREAD makevariant(LUA_TTHREAD, 0) | | ------------------ | | | | 42| 258|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 361| 258| g->currentwhite = bitmask(WHITE0BIT); ------------------ | | 63| 258|#define bitmask(b) (1<<(b)) ------------------ 362| 258| L->marked = luaC_white(g); ------------------ | | 102| 258|#define luaC_white(g) cast_byte((g)->currentwhite & WHITEBITS) | | ------------------ | | | | 143| 258|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 363| 258| preinit_thread(L, g); 364| 258| g->allgc = obj2gco(L); /* by now, only object is the main thread */ ------------------ | | 390| 258|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 258|#define check_exp(c,e) (e) | | ------------------ ------------------ 365| 258| L->next = NULL; 366| 258| incnny(L); /* main thread is always non yieldable */ ------------------ | | 111| 258|#define incnny(L) ((L)->nCcalls += 0x10000) ------------------ 367| 258| g->frealloc = f; 368| 258| g->ud = ud; 369| 258| g->warnf = NULL; 370| 258| g->ud_warn = NULL; 371| 258| g->mainthread = L; 372| 258| g->seed = luai_makeseed(L); 373| 258| g->gcstp = GCSTPGC; /* no GC while building state */ ------------------ | | 156| 258|#define GCSTPGC 2 /* bit true when GC stopped by itself */ ------------------ 374| 258| g->strt.size = g->strt.nuse = 0; 375| 258| g->strt.hash = NULL; 376| 258| setnilvalue(&g->l_registry); ------------------ | | 200| 258|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 258|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 377| 258| g->panic = NULL; 378| 258| g->gcstate = GCSpause; ------------------ | | 39| 258|#define GCSpause 8 ------------------ 379| 258| g->gckind = KGC_INC; ------------------ | | 151| 258|#define KGC_INC 0 /* incremental gc */ ------------------ 380| 258| g->gcstopem = 0; 381| 258| g->gcemergency = 0; 382| 258| g->finobj = g->tobefnz = g->fixedgc = NULL; 383| 258| g->firstold1 = g->survival = g->old1 = g->reallyold = NULL; 384| 258| g->finobjsur = g->finobjold1 = g->finobjrold = NULL; 385| 258| g->sweepgc = NULL; 386| 258| g->gray = g->grayagain = NULL; 387| 258| g->weak = g->ephemeron = g->allweak = NULL; 388| 258| g->twups = NULL; 389| 258| g->totalbytes = sizeof(LG); 390| 258| g->GCdebt = 0; 391| 258| g->lastatomic = 0; 392| 258| setivalue(&g->nilvalue, 0); /* to signal that state is not yet built */ ------------------ | | 345| 258| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 258|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 258|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 393| 258| setgcparam(g->gcpause, LUAI_GCPAUSE); ------------------ | | 136| 258|#define setgcparam(p,v) ((p) = (v) / 4) ------------------ 394| 258| setgcparam(g->gcstepmul, LUAI_GCMUL); ------------------ | | 136| 258|#define setgcparam(p,v) ((p) = (v) / 4) ------------------ 395| 258| g->gcstepsize = LUAI_GCSTEPSIZE; ------------------ | | 141| 258|#define LUAI_GCSTEPSIZE 13 /* 8 KB */ ------------------ 396| 258| setgcparam(g->genmajormul, LUAI_GENMAJORMUL); ------------------ | | 136| 258|#define setgcparam(p,v) ((p) = (v) / 4) ------------------ 397| 258| g->genminormul = LUAI_GENMINORMUL; ------------------ | | 126| 258|#define LUAI_GENMINORMUL 20 ------------------ 398| 2.58k| for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL; ------------------ | | 426| 2.58k|#define LUA_NUMTAGS LUA_NUMTYPES | | ------------------ | | | | 75| 2.58k|#define LUA_NUMTYPES 9 | | ------------------ ------------------ | Branch (398:13): [True: 2.32k, False: 258] ------------------ 399| 258| if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) { ------------------ | | 49| 258|#define LUA_OK 0 ------------------ | Branch (399:7): [True: 0, False: 258] ------------------ 400| | /* memory allocation error: free partial state */ 401| 0| close_state(L); 402| 0| L = NULL; 403| 0| } 404| 258| return L; 405| 258|} lua_close: 408| 258|LUA_API void lua_close (lua_State *L) { 409| 258| lua_lock(L); ------------------ | | 264| 258|#define lua_lock(L) ((void) 0) ------------------ 410| 258| L = G(L)->mainthread; /* only the main thread can be closed */ ------------------ | | 335| 258|#define G(L) (L->l_G) ------------------ 411| 258| close_state(L); 412| 258|} lstate.c:preinit_thread: 249| 258|static void preinit_thread (lua_State *L, global_State *g) { 250| 258| G(L) = g; ------------------ | | 335| 258|#define G(L) (L->l_G) ------------------ 251| 258| L->stack.p = NULL; 252| 258| L->ci = NULL; 253| 258| L->nci = 0; 254| 258| L->twups = L; /* thread has no upvalues */ 255| 258| L->nCcalls = 0; 256| 258| L->errorJmp = NULL; 257| 258| L->hook = NULL; 258| 258| L->hookmask = 0; 259| 258| L->basehookcount = 0; 260| 258| L->allowhook = 1; 261| 258| resethookcount(L); ------------------ | | 21| 258|#define resethookcount(L) (L->hookcount = L->basehookcount) ------------------ 262| 258| L->openupval = NULL; 263| 258| L->status = LUA_OK; ------------------ | | 49| 258|#define LUA_OK 0 ------------------ 264| 258| L->errfunc = 0; 265| 258| L->oldpc = 0; 266| 258|} lstate.c:stack_init: 180| 258|static void stack_init (lua_State *L1, lua_State *L) { 181| 258| int i; CallInfo *ci; 182| | /* initialize stack array */ 183| 258| L1->stack.p = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, StackValue); ------------------ | | 60| 258|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 184| 258| L1->tbclist.p = L1->stack.p; 185| 11.8k| for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++) ------------------ | | 145| 11.8k|#define BASIC_STACK_SIZE (2*LUA_MINSTACK) | | ------------------ | | | | 80| 11.8k|#define LUA_MINSTACK 20 | | ------------------ ------------------ for (i = 0; i < BASIC_STACK_SIZE + EXTRA_STACK; i++) ------------------ | | 142| 11.8k|#define EXTRA_STACK 5 ------------------ | Branch (185:15): [True: 11.6k, False: 258] ------------------ 186| 11.6k| setnilvalue(s2v(L1->stack.p + i)); /* erase new stack */ ------------------ | | 200| 11.6k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 11.6k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 187| 258| L1->top.p = L1->stack.p; 188| 258| L1->stack_last.p = L1->stack.p + BASIC_STACK_SIZE; ------------------ | | 145| 258|#define BASIC_STACK_SIZE (2*LUA_MINSTACK) | | ------------------ | | | | 80| 258|#define LUA_MINSTACK 20 | | ------------------ ------------------ 189| | /* initialize first ci */ 190| 258| ci = &L1->base_ci; 191| 258| ci->next = ci->previous = NULL; 192| 258| ci->callstatus = CIST_C; ------------------ | | 211| 258|#define CIST_C (1<<1) /* call is running a C function */ ------------------ 193| 258| ci->func.p = L1->top.p; 194| 258| ci->u.c.k = NULL; 195| 258| ci->nresults = 0; 196| 258| setnilvalue(s2v(L1->top.p)); /* 'function' entry for this 'ci' */ ------------------ | | 200| 258|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 258|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 197| 258| L1->top.p++; 198| 258| ci->top.p = L1->top.p + LUA_MINSTACK; ------------------ | | 80| 258|#define LUA_MINSTACK 20 ------------------ 199| 258| L1->ci = ci; 200| 258|} lstate.c:freestack: 203| 258|static void freestack (lua_State *L) { 204| 258| if (L->stack.p == NULL) ------------------ | Branch (204:7): [True: 0, False: 258] ------------------ 205| 0| return; /* stack not completely built yet */ 206| 258| L->ci = &L->base_ci; /* free the entire 'ci' list */ 207| 258| luaE_freeCI(L); 208| 258| lua_assert(L->nci == 0); ------------------ | | 114| 258|#define lua_assert(c) ((void)0) ------------------ 209| 258| luaM_freearray(L, L->stack.p, stacksize(L) + EXTRA_STACK); /* free stack */ ------------------ | | 57| 258|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 210| 258|} lstate.c:luai_makeseed: 71| 258|static unsigned int luai_makeseed (lua_State *L) { 72| 258| char buff[3 * sizeof(size_t)]; 73| 258| unsigned int h = cast_uint(time(NULL)); ------------------ | | 142| 258|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 74| 258| int p = 0; 75| 258| addbuff(buff, p, L); /* heap variable */ ------------------ | | 68| 258| { size_t t = cast_sizet(e); \ | | ------------------ | | | | 147| 258|#define cast_sizet(i) cast(size_t, (i)) | | | | ------------------ | | | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 69| 258| memcpy(b + p, &t, sizeof(t)); p += sizeof(t); } ------------------ 76| 258| addbuff(buff, p, &h); /* local variable */ ------------------ | | 68| 258| { size_t t = cast_sizet(e); \ | | ------------------ | | | | 147| 258|#define cast_sizet(i) cast(size_t, (i)) | | | | ------------------ | | | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 69| 258| memcpy(b + p, &t, sizeof(t)); p += sizeof(t); } ------------------ 77| 258| addbuff(buff, p, &lua_newstate); /* public function */ ------------------ | | 68| 258| { size_t t = cast_sizet(e); \ | | ------------------ | | | | 147| 258|#define cast_sizet(i) cast(size_t, (i)) | | | | ------------------ | | | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 69| 258| memcpy(b + p, &t, sizeof(t)); p += sizeof(t); } ------------------ 78| 258| lua_assert(p == sizeof(buff)); ------------------ | | 114| 258|#define lua_assert(c) ((void)0) ------------------ 79| 258| return luaS_hash(buff, p, h); 80| 258|} lstate.c:f_luaopen: 231| 258|static void f_luaopen (lua_State *L, void *ud) { 232| 258| global_State *g = G(L); ------------------ | | 335| 258|#define G(L) (L->l_G) ------------------ 233| 258| UNUSED(ud); ------------------ | | 131| 258|#define UNUSED(x) ((void)(x)) ------------------ 234| 258| stack_init(L, L); /* init stack */ 235| 258| init_registry(L, g); 236| 258| luaS_init(L); 237| 258| luaT_init(L); 238| 258| luaX_init(L); 239| 258| g->gcstp = 0; /* allow gc */ 240| 258| setnilvalue(&g->nilvalue); /* now state is complete */ ------------------ | | 200| 258|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 258|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 241| 258| luai_userstateopen(L); ------------------ | | 282| 258|#define luai_userstateopen(L) ((void)L) ------------------ 242| 258|} lstate.c:init_registry: 216| 258|static void init_registry (lua_State *L, global_State *g) { 217| | /* create registry */ 218| 258| Table *registry = luaH_new(L); 219| 258| sethvalue(L, &g->l_registry, registry); ------------------ | | 687| 258| { TValue *io = (obj); Table *x_ = (x); \ | | 688| 258| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 258|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 390| 258|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 258|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 258|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 689| 258| checkliveness(L,io); } | | ------------------ | | | | 107| 258| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 258|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 258| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 220| 258| luaH_resize(L, registry, LUA_RIDX_LAST, 0); ------------------ | | 86| 258|#define LUA_RIDX_LAST LUA_RIDX_GLOBALS | | ------------------ | | | | 85| 258|#define LUA_RIDX_GLOBALS 2 | | ------------------ ------------------ 221| | /* registry[LUA_RIDX_MAINTHREAD] = L */ 222| 258| setthvalue(L, ®istry->array[LUA_RIDX_MAINTHREAD - 1], L); ------------------ | | 269| 258| { TValue *io = (obj); lua_State *x_ = (x); \ | | 270| 258| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 72| 258|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 390| 258|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 258|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTHREAD)); \ | | ------------------ | | | | 114| 258|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 271| 258| checkliveness(L,io); } | | ------------------ | | | | 107| 258| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 258|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 258| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 223| | /* registry[LUA_RIDX_GLOBALS] = new table (table of globals) */ 224| 258| sethvalue(L, ®istry->array[LUA_RIDX_GLOBALS - 1], luaH_new(L)); ------------------ | | 687| 258| { TValue *io = (obj); Table *x_ = (x); \ | | 688| 258| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 72| 258|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 390| 258|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 258|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | ------------------ | | | | 114| 258|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 689| 258| checkliveness(L,io); } | | ------------------ | | | | 107| 258| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 258|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 258| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 225| 258|} lstate.c:close_state: 269| 258|static void close_state (lua_State *L) { 270| 258| global_State *g = G(L); ------------------ | | 335| 258|#define G(L) (L->l_G) ------------------ 271| 258| if (!completestate(g)) /* closing a partially built state? */ ------------------ | | 341| 258|#define completestate(g) ttisnil(&g->nilvalue) | | ------------------ | | | | 193| 258|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 258|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 258|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 258|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (271:7): [True: 0, False: 258] ------------------ 272| 0| luaC_freeallobjects(L); /* just collect its objects */ 273| 258| else { /* closing a fully built state */ 274| 258| L->ci = &L->base_ci; /* unwind CallInfo list */ 275| 258| luaD_closeprotected(L, 1, LUA_OK); /* close all upvalues */ ------------------ | | 49| 258|#define LUA_OK 0 ------------------ 276| 258| luaC_freeallobjects(L); /* collect all objects */ 277| 258| luai_userstateclose(L); ------------------ | | 286| 258|#define luai_userstateclose(L) ((void)L) ------------------ 278| 258| } 279| 258| luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size); ------------------ | | 57| 258|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 280| 258| freestack(L); 281| 258| lua_assert(gettotalbytes(g) == sizeof(LG)); ------------------ | | 114| 258|#define lua_assert(c) ((void)0) ------------------ 282| 258| (*g->frealloc)(g->ud, fromstate(L), sizeof(LG), 0); /* free main block */ ------------------ | | 51| 258|#define fromstate(L) (cast(LX *, cast(lu_byte *, (L)) - offsetof(LX, l))) | | ------------------ | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 283| 258|} luaS_eqlngstr: 34| 37.2k|int luaS_eqlngstr (TString *a, TString *b) { 35| 37.2k| size_t len = a->u.lnglen; 36| 37.2k| lua_assert(a->tt == LUA_VLNGSTR && b->tt == LUA_VLNGSTR); ------------------ | | 114| 37.2k|#define lua_assert(c) ((void)0) ------------------ 37| 37.2k| return (a == b) || /* same instance or... */ ------------------ | Branch (37:10): [True: 22.5k, False: 14.6k] ------------------ 38| 37.2k| ((len == b->u.lnglen) && /* equal length and ... */ ------------------ | Branch (38:6): [True: 11.5k, False: 3.13k] ------------------ 39| 14.6k| (memcmp(getstr(a), getstr(b), len) == 0)); /* equal contents */ ------------------ | | 403| 11.5k|#define getstr(ts) ((ts)->contents) ------------------ (memcmp(getstr(a), getstr(b), len) == 0)); /* equal contents */ ------------------ | | 403| 11.5k|#define getstr(ts) ((ts)->contents) ------------------ | Branch (39:6): [True: 10.6k, False: 887] ------------------ 40| 37.2k|} luaS_hash: 43| 7.79M|unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) { 44| 7.79M| unsigned int h = seed ^ cast_uint(l); ------------------ | | 142| 7.79M|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 7.79M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 45| 595M| for (; l > 0; l--) ------------------ | Branch (45:10): [True: 587M, False: 7.79M] ------------------ 46| 587M| h ^= ((h<<5) + (h>>2) + cast_byte(str[l - 1])); ------------------ | | 143| 587M|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 587M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 47| 7.79M| return h; 48| 7.79M|} luaS_hashlongstr: 51| 34.3k|unsigned int luaS_hashlongstr (TString *ts) { 52| 34.3k| lua_assert(ts->tt == LUA_VLNGSTR); ------------------ | | 114| 34.3k|#define lua_assert(c) ((void)0) ------------------ 53| 34.3k| if (ts->extra == 0) { /* no hash? */ ------------------ | Branch (53:7): [True: 12.8k, False: 21.5k] ------------------ 54| 12.8k| size_t len = ts->u.lnglen; 55| 12.8k| ts->hash = luaS_hash(getstr(ts), len, ts->hash); ------------------ | | 403| 12.8k|#define getstr(ts) ((ts)->contents) ------------------ 56| 12.8k| ts->extra = 1; /* now it has its hash */ 57| 12.8k| } 58| 34.3k| return ts->hash; 59| 34.3k|} luaS_resize: 85| 130|void luaS_resize (lua_State *L, int nsize) { 86| 130| stringtable *tb = &G(L)->strt; ------------------ | | 335| 130|#define G(L) (L->l_G) ------------------ 87| 130| int osize = tb->size; 88| 130| TString **newvect; 89| 130| if (nsize < osize) /* shrinking table? */ ------------------ | Branch (89:7): [True: 22, False: 108] ------------------ 90| 22| tablerehash(tb->hash, osize, nsize); /* depopulate shrinking part */ 91| 130| newvect = luaM_reallocvector(L, tb->hash, osize, nsize, TString*); ------------------ | | 71| 130| (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \ | | ------------------ | | | | 136| 130|#define cast(t, exp) ((t)(exp)) | | ------------------ | | 72| 130| cast_sizet(n) * sizeof(t)))) ------------------ 92| 130| if (l_unlikely(newvect == NULL)) { /* reallocation failed? */ ------------------ | | 688| 130|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 130|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 130] | | | | ------------------ | | ------------------ ------------------ 93| 0| if (nsize < osize) /* was it shrinking table? */ ------------------ | Branch (93:9): [True: 0, False: 0] ------------------ 94| 0| tablerehash(tb->hash, nsize, osize); /* restore to original size */ 95| | /* leave table as it was */ 96| 0| } 97| 130| else { /* allocation succeeded */ 98| 130| tb->hash = newvect; 99| 130| tb->size = nsize; 100| 130| if (nsize > osize) ------------------ | Branch (100:9): [True: 108, False: 22] ------------------ 101| 108| tablerehash(newvect, osize, nsize); /* rehash for new size */ 102| 130| } 103| 130|} luaS_clearcache: 110| 1.00k|void luaS_clearcache (global_State *g) { 111| 1.00k| int i, j; 112| 54.2k| for (i = 0; i < STRCACHE_N; i++) ------------------ | | 237| 54.2k|#define STRCACHE_N 53 ------------------ | Branch (112:15): [True: 53.2k, False: 1.00k] ------------------ 113| 159k| for (j = 0; j < STRCACHE_M; j++) { ------------------ | | 238| 159k|#define STRCACHE_M 2 ------------------ | Branch (113:17): [True: 106k, False: 53.2k] ------------------ 114| 106k| if (iswhite(g->strcache[i][j])) /* will entry be collected? */ ------------------ | | 87| 106k|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | ------------------ | | | | 62| 106k|#define testbits(x,m) ((x) & (m)) | | | | ------------------ | | | | | Branch (62:24): [True: 0, False: 106k] | | | | ------------------ | | ------------------ ------------------ 115| 0| g->strcache[i][j] = g->memerrmsg; /* replace it with something fixed */ 116| 106k| } 117| 1.00k|} luaS_init: 123| 258|void luaS_init (lua_State *L) { 124| 258| global_State *g = G(L); ------------------ | | 335| 258|#define G(L) (L->l_G) ------------------ 125| 258| int i, j; 126| 258| stringtable *tb = &G(L)->strt; ------------------ | | 335| 258|#define G(L) (L->l_G) ------------------ 127| 258| tb->hash = luaM_newvector(L, MINSTRTABSIZE, TString*); ------------------ | | 60| 258|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 128| 258| tablerehash(tb->hash, 0, MINSTRTABSIZE); /* clear array */ ------------------ | | 227| 258|#define MINSTRTABSIZE 128 ------------------ 129| 258| tb->size = MINSTRTABSIZE; ------------------ | | 227| 258|#define MINSTRTABSIZE 128 ------------------ 130| | /* pre-create memory-error message */ 131| 258| g->memerrmsg = luaS_newliteral(L, MEMERRMSG); ------------------ | | 28| 258|#define luaS_newliteral(L, s) (luaS_newlstr(L, "" s, \ | | 29| 258| (sizeof(s)/sizeof(char))-1)) ------------------ 132| 258| luaC_fix(L, obj2gco(g->memerrmsg)); /* it should never be collected */ ------------------ | | 390| 258|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 258|#define check_exp(c,e) (e) | | ------------------ ------------------ 133| 13.9k| for (i = 0; i < STRCACHE_N; i++) /* fill cache with valid strings */ ------------------ | | 237| 13.9k|#define STRCACHE_N 53 ------------------ | Branch (133:15): [True: 13.6k, False: 258] ------------------ 134| 41.0k| for (j = 0; j < STRCACHE_M; j++) ------------------ | | 238| 41.0k|#define STRCACHE_M 2 ------------------ | Branch (134:17): [True: 27.3k, False: 13.6k] ------------------ 135| 27.3k| g->strcache[i][j] = g->memerrmsg; 136| 258|} luaS_createlngstrobj: 157| 13.3k|TString *luaS_createlngstrobj (lua_State *L, size_t l) { 158| 13.3k| TString *ts = createstrobj(L, l, LUA_VLNGSTR, G(L)->seed); ------------------ | | 361| 13.3k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 13.3k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ TString *ts = createstrobj(L, l, LUA_VLNGSTR, G(L)->seed); ------------------ | | 335| 13.3k|#define G(L) (L->l_G) ------------------ 159| 13.3k| ts->u.lnglen = l; 160| 13.3k| return ts; 161| 13.3k|} luaS_remove: 164| 257k|void luaS_remove (lua_State *L, TString *ts) { 165| 257k| stringtable *tb = &G(L)->strt; ------------------ | | 335| 257k|#define G(L) (L->l_G) ------------------ 166| 257k| TString **p = &tb->hash[lmod(ts->hash, tb->size)]; ------------------ | | 789| 257k| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 115| 257k|#define check_exp(c,e) (e) | | ------------------ ------------------ 167| 290k| while (*p != ts) /* find previous element */ ------------------ | Branch (167:10): [True: 32.8k, False: 257k] ------------------ 168| 32.8k| p = &(*p)->u.hnext; 169| 257k| *p = (*p)->u.hnext; /* remove element from its list */ 170| 257k| tb->nuse--; 171| 257k|} luaS_newlstr: 221| 7.79M|TString *luaS_newlstr (lua_State *L, const char *str, size_t l) { 222| 7.79M| if (l <= LUAI_MAXSHORTLEN) /* short string? */ ------------------ | | 216| 7.79M|#define LUAI_MAXSHORTLEN 40 ------------------ | Branch (222:7): [True: 7.78M, False: 12.7k] ------------------ 223| 7.78M| return internshrstr(L, str, l); 224| 12.7k| else { 225| 12.7k| TString *ts; 226| 12.7k| if (l_unlikely(l >= (MAX_SIZE - sizeof(TString))/sizeof(char))) ------------------ | | 688| 12.7k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 25.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 12.7k] | | | | | Branch (676:46): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 227| 0| luaM_toobig(L); 228| 12.7k| ts = luaS_createlngstrobj(L, l); 229| 12.7k| memcpy(getstr(ts), str, l * sizeof(char)); ------------------ | | 403| 12.7k|#define getstr(ts) ((ts)->contents) ------------------ 230| 12.7k| return ts; 231| 12.7k| } 232| 7.79M|} luaS_new: 241| 12.5k|TString *luaS_new (lua_State *L, const char *str) { 242| 12.5k| unsigned int i = point2uint(str) % STRCACHE_N; /* hash */ ------------------ | | 91| 12.5k|#define point2uint(p) ((unsigned int)((L_P2I)(p) & UINT_MAX)) ------------------ unsigned int i = point2uint(str) % STRCACHE_N; /* hash */ ------------------ | | 237| 12.5k|#define STRCACHE_N 53 ------------------ 243| 12.5k| int j; 244| 12.5k| TString **p = G(L)->strcache[i]; ------------------ | | 335| 12.5k|#define G(L) (L->l_G) ------------------ 245| 37.5k| for (j = 0; j < STRCACHE_M; j++) { ------------------ | | 238| 37.5k|#define STRCACHE_M 2 ------------------ | Branch (245:15): [True: 25.0k, False: 12.4k] ------------------ 246| 25.0k| if (strcmp(str, getstr(p[j])) == 0) /* hit? */ ------------------ | | 403| 25.0k|#define getstr(ts) ((ts)->contents) ------------------ | Branch (246:9): [True: 65, False: 24.9k] ------------------ 247| 65| return p[j]; /* that is it */ 248| 25.0k| } 249| | /* normal route */ 250| 24.9k| for (j = STRCACHE_M - 1; j > 0; j--) ------------------ | | 238| 12.4k|#define STRCACHE_M 2 ------------------ | Branch (250:28): [True: 12.4k, False: 12.4k] ------------------ 251| 12.4k| p[j] = p[j - 1]; /* move out last element */ 252| | /* new element is first in the list */ 253| 12.4k| p[0] = luaS_newlstr(L, str, strlen(str)); 254| 12.4k| return p[0]; 255| 12.5k|} luaS_newudata: 258| 11|Udata *luaS_newudata (lua_State *L, size_t s, int nuvalue) { 259| 11| Udata *u; 260| 11| int i; 261| 11| GCObject *o; 262| 11| if (l_unlikely(s > MAX_SIZE - udatamemoffset(nuvalue))) ------------------ | | 688| 11|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 44|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 11] | | | | | Branch (676:46): [Folded - Ignored] | | | | | Branch (676:46): [True: 11, False: 0] | | | | ------------------ | | ------------------ ------------------ 263| 0| luaM_toobig(L); 264| 11| o = luaC_newobj(L, LUA_VUSERDATA, sizeudata(nuvalue, s)); ------------------ | | 431| 11|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 11|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ o = luaC_newobj(L, LUA_VUSERDATA, sizeudata(nuvalue, s)); ------------------ | | 498| 11|#define sizeudata(nuv,nb) (udatamemoffset(nuv) + (nb)) | | ------------------ | | | | 491| 11| ((nuv) == 0 ? offsetof(Udata0, bindata) \ | | | | ------------------ | | | | | Branch (491:3): [True: 11, False: 0] | | | | ------------------ | | | | 492| 11| : offsetof(Udata, uv) + (sizeof(UValue) * (nuv))) | | ------------------ ------------------ 265| 11| u = gco2u(o); ------------------ | | 375| 11|#define gco2u(o) check_exp((o)->tt == LUA_VUSERDATA, &((cast_u(o))->u)) | | ------------------ | | | | 115| 11|#define check_exp(c,e) (e) | | ------------------ ------------------ 266| 11| u->len = s; 267| 11| u->nuvalue = nuvalue; 268| 11| u->metatable = NULL; 269| 11| for (i = 0; i < nuvalue; i++) ------------------ | Branch (269:15): [True: 0, False: 11] ------------------ 270| 11| setnilvalue(&u->uv[i].uv); ------------------ | | 200| 0|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 11|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 271| 11| return u; 272| 11|} lstring.c:tablerehash: 62| 388|static void tablerehash (TString **vect, int osize, int nsize) { 63| 388| int i; 64| 207k| for (i = osize; i < nsize; i++) /* clear new elements */ ------------------ | Branch (64:19): [True: 206k, False: 388] ------------------ 65| 206k| vect[i] = NULL; 66| 436k| for (i = 0; i < osize; i++) { /* rehash old part of the array */ ------------------ | Branch (66:15): [True: 435k, False: 388] ------------------ 67| 435k| TString *p = vect[i]; 68| 435k| vect[i] = NULL; 69| 613k| while (p) { /* for each string in the list */ ------------------ | Branch (69:12): [True: 177k, False: 435k] ------------------ 70| 177k| TString *hnext = p->u.hnext; /* save next */ 71| 177k| unsigned int h = lmod(p->hash, nsize); /* new position */ ------------------ | | 789| 177k| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 115| 177k|#define check_exp(c,e) (e) | | ------------------ ------------------ 72| 177k| p->u.hnext = vect[h]; /* chain it into array */ 73| 177k| vect[h] = p; 74| 177k| p = hnext; 75| 177k| } 76| 435k| } 77| 388|} lstring.c:createstrobj: 143| 270k|static TString *createstrobj (lua_State *L, size_t l, int tag, unsigned int h) { 144| 270k| TString *ts; 145| 270k| GCObject *o; 146| 270k| size_t totalsize; /* total size of TString object */ 147| 270k| totalsize = sizelstring(l); ------------------ | | 26| 270k|#define sizelstring(l) (offsetof(TString, contents) + ((l) + 1) * sizeof(char)) ------------------ 148| 270k| o = luaC_newobj(L, tag, totalsize); 149| 270k| ts = gco2ts(o); ------------------ | | 374| 270k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | ------------------ | | | | 115| 270k|#define check_exp(c,e) (e) | | ------------------ ------------------ 150| 270k| ts->hash = h; 151| 270k| ts->extra = 0; 152| 270k| getstr(ts)[l] = '\0'; /* ending 0 */ ------------------ | | 403| 270k|#define getstr(ts) ((ts)->contents) ------------------ 153| 270k| return ts; 154| 270k|} lstring.c:internshrstr: 188| 7.78M|static TString *internshrstr (lua_State *L, const char *str, size_t l) { 189| 7.78M| TString *ts; 190| 7.78M| global_State *g = G(L); ------------------ | | 335| 7.78M|#define G(L) (L->l_G) ------------------ 191| 7.78M| stringtable *tb = &g->strt; 192| 7.78M| unsigned int h = luaS_hash(str, l, g->seed); 193| 7.78M| TString **list = &tb->hash[lmod(h, tb->size)]; ------------------ | | 789| 7.78M| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 115| 7.78M|#define check_exp(c,e) (e) | | ------------------ ------------------ 194| 7.78M| lua_assert(str != NULL); /* otherwise 'memcmp'/'memcpy' are undefined */ ------------------ | | 114| 7.78M|#define lua_assert(c) ((void)0) ------------------ 195| 10.3M| for (ts = *list; ts != NULL; ts = ts->u.hnext) { ------------------ | Branch (195:20): [True: 10.0M, False: 257k] ------------------ 196| 10.0M| if (l == ts->shrlen && (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) { ------------------ | | 403| 7.83M|#define getstr(ts) ((ts)->contents) ------------------ | Branch (196:9): [True: 7.83M, False: 2.21M] | Branch (196:28): [True: 7.52M, False: 314k] ------------------ 197| | /* found! */ 198| 7.52M| if (isdead(g, ts)) /* dead (but not collected yet)? */ ------------------ | | 96| 7.52M|#define isdead(g,v) isdeadm(otherwhite(g), (v)->marked) | | ------------------ | | | | 95| 7.52M|#define isdeadm(ow,m) ((m) & (ow)) | | | | ------------------ | | | | | Branch (95:23): [True: 0, False: 7.52M] | | | | ------------------ | | ------------------ ------------------ 199| 0| changewhite(ts); /* resurrect it */ ------------------ | | 98| 0|#define changewhite(x) ((x)->marked ^= WHITEBITS) | | ------------------ | | | | 84| 0|#define WHITEBITS bit2mask(WHITE0BIT, WHITE1BIT) | | | | ------------------ | | | | | | 64| 0|#define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 0|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | | | #define bit2mask(b1,b2) (bitmask(b1) | bitmask(b2)) | | | | | | ------------------ | | | | | | | | 63| 0|#define bitmask(b) (1<<(b)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 200| 7.52M| return ts; 201| 7.52M| } 202| 10.0M| } 203| | /* else must create a new string */ 204| 257k| if (tb->nuse >= tb->size) { /* need to grow string table? */ ------------------ | Branch (204:7): [True: 108, False: 257k] ------------------ 205| 108| growstrtab(L, tb); 206| 108| list = &tb->hash[lmod(h, tb->size)]; /* rehash with new size */ ------------------ | | 789| 108| (check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1))))) | | ------------------ | | | | 115| 108|#define check_exp(c,e) (e) | | ------------------ ------------------ 207| 108| } 208| 257k| ts = createstrobj(L, l, LUA_VSHRSTR, h); ------------------ | | 360| 257k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 257k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 209| 257k| memcpy(getstr(ts), str, l * sizeof(char)); ------------------ | | 403| 257k|#define getstr(ts) ((ts)->contents) ------------------ 210| 257k| ts->shrlen = cast_byte(l); ------------------ | | 143| 257k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 257k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 211| 257k| ts->u.hnext = *list; 212| 257k| *list = ts; 213| 257k| tb->nuse++; 214| 257k| return ts; 215| 7.78M|} lstring.c:growstrtab: 174| 108|static void growstrtab (lua_State *L, stringtable *tb) { 175| 108| if (l_unlikely(tb->nuse == MAX_INT)) { /* too many strings? */ ------------------ | | 688| 108|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 108|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 108] | | | | ------------------ | | ------------------ ------------------ 176| 0| luaC_fullgc(L, 1); /* try to free some... */ 177| 0| if (tb->nuse == MAX_INT) /* still too many? */ ------------------ | | 53| 0|#define MAX_INT INT_MAX /* maximum value of an int */ ------------------ | Branch (177:9): [True: 0, False: 0] ------------------ 178| 0| luaM_error(L); /* cannot even create a message... */ ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 53| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 179| 0| } 180| 108| if (tb->size <= MAXSTRTB / 2) /* can grow string table? */ ------------------ | | 28| 108|#define MAXSTRTB cast_int(luaM_limitN(MAX_INT, TString*)) | | ------------------ | | | | 141| 108|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 216|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | | | | Branch (136:27): [Folded - Ignored] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (180:7): [True: 108, False: 0] ------------------ 181| 108| luaS_resize(L, tb->size * 2); 182| 108|} luaH_realasize: 250| 823k|LUAI_FUNC unsigned int luaH_realasize (const Table *t) { 251| 823k| if (limitequalsasize(t)) ------------------ | | 244| 823k|#define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 734| 1.64M|#define isrealasize(t) (!((t)->flags & BITRAS)) | | | | ------------------ | | | | | | 733| 823k|#define BITRAS (1 << 7) | | | | ------------------ | | | | | Branch (734:25): [True: 440k, False: 383k] | | | | ------------------ | | ------------------ | | #define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 66| 383k|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | | | ------------------ | | | | | Branch (66:19): [True: 15, False: 383k] | | | | ------------------ | | ------------------ ------------------ 252| 440k| return t->alimit; /* this is the size */ 253| 383k| else { 254| 383k| unsigned int size = t->alimit; 255| | /* compute the smallest power of 2 not smaller than 'n' */ 256| 383k| size |= (size >> 1); 257| 383k| size |= (size >> 2); 258| 383k| size |= (size >> 4); 259| 383k| size |= (size >> 8); 260| 383k|#if (UINT_MAX >> 14) > 3 /* unsigned int has more than 16 bits */ 261| 383k| size |= (size >> 16); 262| |#if (UINT_MAX >> 30) > 3 263| | size |= (size >> 32); /* unsigned int has more than 32 bits */ 264| |#endif 265| 383k|#endif 266| 383k| size++; 267| 383k| lua_assert(ispow2(size) && size/2 < t->alimit && t->alimit < size); ------------------ | | 114| 383k|#define lua_assert(c) ((void)0) ------------------ 268| 383k| return size; 269| 383k| } 270| 823k|} luaH_resize: 554| 121k| unsigned int nhsize) { 555| 121k| unsigned int i; 556| 121k| Table newt; /* to keep the new hash part */ 557| 121k| unsigned int oldasize = setlimittosize(t); 558| 121k| TValue *newarray; 559| | /* create new hash part with appropriate size into 'newt' */ 560| 121k| setnodevector(L, &newt, nhsize); 561| 121k| if (newasize < oldasize) { /* will array shrink? */ ------------------ | Branch (561:7): [True: 0, False: 121k] ------------------ 562| 0| t->alimit = newasize; /* pretend array has new size... */ 563| 0| exchangehashpart(t, &newt); /* and new hash */ 564| | /* re-insert into the new hash the elements from vanishing slice */ 565| 0| for (i = newasize; i < oldasize; i++) { ------------------ | Branch (565:24): [True: 0, False: 0] ------------------ 566| 0| if (!isempty(&t->array[i])) ------------------ | | 217| 0|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (566:11): [True: 0, False: 0] ------------------ 567| 0| luaH_setint(L, t, i + 1, &t->array[i]); 568| 0| } 569| 0| t->alimit = oldasize; /* restore current size... */ 570| 0| exchangehashpart(t, &newt); /* and hash (in case of errors) */ 571| 0| } 572| | /* allocate new array */ 573| 121k| newarray = luaM_reallocvector(L, t->array, oldasize, newasize, TValue); ------------------ | | 71| 121k| (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \ | | ------------------ | | | | 136| 121k|#define cast(t, exp) ((t)(exp)) | | ------------------ | | 72| 121k| cast_sizet(n) * sizeof(t)))) ------------------ 574| 121k| if (l_unlikely(newarray == NULL && newasize > 0)) { /* allocation failed? */ ------------------ | | 688| 121k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 123k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 121k] | | | | | Branch (676:46): [True: 1.47k, False: 120k] | | | | | Branch (676:46): [True: 0, False: 1.47k] | | | | ------------------ | | ------------------ ------------------ 575| 0| freehash(L, &newt); /* release new hash part */ 576| 0| luaM_error(L); /* raise error (with array unchanged) */ ------------------ | | 17| 0|#define luaM_error(L) luaD_throw(L, LUA_ERRMEM) | | ------------------ | | | | 53| 0|#define LUA_ERRMEM 4 | | ------------------ ------------------ 577| 0| } 578| | /* allocation ok; initialize new part of the array */ 579| 121k| exchangehashpart(t, &newt); /* 't' has the new hash ('newt' has the old) */ 580| 121k| t->array = newarray; /* set new array part */ 581| 121k| t->alimit = newasize; 582| 504k| for (i = oldasize; i < newasize; i++) /* clear new slice of the array */ ------------------ | Branch (582:22): [True: 382k, False: 121k] ------------------ 583| 382k| setempty(&t->array[i]); ------------------ | | 225| 382k|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 504k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 584| | /* re-insert elements from old hash part into new parts */ 585| 121k| reinsert(L, &newt, t); /* 'newt' now has the old hash */ 586| 121k| freehash(L, &newt); /* free old hash part */ 587| 121k|} luaH_resizearray: 590| 1|void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize) { 591| 1| int nsize = allocsizenode(t); ------------------ | | 31| 1|#define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 27| 1|#define isdummy(t) ((t)->lastfree == NULL) | | | | ------------------ | | | | | Branch (27:21): [True: 1, False: 0] | | | | ------------------ | | ------------------ | | #define allocsizenode(t) (isdummy(t) ? 0 : sizenode(t)) | | ------------------ | | | | 793| 0|#define sizenode(t) (twoto((t)->lsizenode)) | | | | ------------------ | | | | | | 792| 0|#define twoto(x) (1<<(x)) | | | | ------------------ | | ------------------ ------------------ 592| 1| luaH_resize(L, t, nasize, nsize); 593| 1|} luaH_new: 626| 120k|Table *luaH_new (lua_State *L) { 627| 120k| GCObject *o = luaC_newobj(L, LUA_VTABLE, sizeof(Table)); ------------------ | | 680| 120k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 120k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ 628| 120k| Table *t = gco2t(o); ------------------ | | 380| 120k|#define gco2t(o) check_exp((o)->tt == LUA_VTABLE, &((cast_u(o))->h)) | | ------------------ | | | | 115| 120k|#define check_exp(c,e) (e) | | ------------------ ------------------ 629| 120k| t->metatable = NULL; 630| 120k| t->flags = cast_byte(maskflags); /* table has no metamethod fields */ ------------------ | | 143| 120k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 120k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 631| 120k| t->array = NULL; 632| 120k| t->alimit = 0; 633| 120k| setnodevector(L, t, 0); 634| 120k| return t; 635| 120k|} luaH_free: 638| 120k|void luaH_free (lua_State *L, Table *t) { 639| 120k| freehash(L, t); 640| 120k| luaM_freearray(L, t->array, luaH_realasize(t)); ------------------ | | 57| 120k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 641| 120k| luaM_free(L, t); ------------------ | | 56| 120k|#define luaM_free(L, b) luaM_free_(L, (b), sizeof(*(b))) ------------------ 642| 120k|} luaH_newkey: 665| 896k|void luaH_newkey (lua_State *L, Table *t, const TValue *key, TValue *value) { 666| 896k| Node *mp; 667| 896k| TValue aux; 668| 896k| if (l_unlikely(ttisnil(key))) ------------------ | | 688| 896k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 896k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 896k] | | | | ------------------ | | ------------------ ------------------ 669| 0| luaG_runerror(L, "table index is nil"); 670| 896k| else if (ttisfloat(key)) { ------------------ | | 327| 896k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 896k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 896k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 97.3k, False: 798k] | | | | ------------------ | | ------------------ ------------------ 671| 97.3k| lua_Number f = fltvalue(key); ------------------ | | 332| 97.3k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 97.3k|#define check_exp(c,e) (e) | | ------------------ ------------------ 672| 97.3k| lua_Integer k; 673| 97.3k| if (luaV_flttointeger(f, &k, F2Ieq)) { /* does key fit in an integer? */ ------------------ | Branch (673:9): [True: 91.9k, False: 5.42k] ------------------ 674| 91.9k| setivalue(&aux, k); ------------------ | | 345| 91.9k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 91.9k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 91.9k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 675| 91.9k| key = &aux; /* insert it as an integer */ 676| 91.9k| } 677| 5.42k| else if (l_unlikely(luai_numisnan(f))) ------------------ | | 688| 5.42k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 5.42k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 5.42k] | | | | ------------------ | | ------------------ ------------------ 678| 0| luaG_runerror(L, "table index is NaN"); 679| 97.3k| } 680| 896k| if (ttisnil(value)) ------------------ | | 193| 896k|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 896k|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 896k|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 896k|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 207k, False: 688k] | | | | ------------------ | | ------------------ ------------------ 681| 207k| return; /* do not insert nil values */ 682| 688k| mp = mainpositionTV(t, key); 683| 688k| if (!isempty(gval(mp)) || isdummy(t)) { /* main position is taken? */ ------------------ | | 217| 688k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 688k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 1.37M|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 688k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 688k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (!isempty(gval(mp)) || isdummy(t)) { /* main position is taken? */ ------------------ | | 27| 391k|#define isdummy(t) ((t)->lastfree == NULL) | | ------------------ | | | Branch (27:21): [True: 254, False: 391k] | | ------------------ ------------------ | Branch (683:7): [True: 296k, False: 391k] ------------------ 684| 297k| Node *othern; 685| 297k| Node *f = getfreepos(t); /* get a free place */ 686| 297k| if (f == NULL) { /* cannot find a free place? */ ------------------ | Branch (686:9): [True: 1.90k, False: 295k] ------------------ 687| 1.90k| rehash(L, t, key); /* grow table */ 688| | /* whatever called 'newkey' takes care of TM cache */ 689| 1.90k| luaH_set(L, t, key, value); /* insert key into grown table */ 690| 1.90k| return; 691| 1.90k| } 692| 295k| lua_assert(!isdummy(t)); ------------------ | | 114| 295k|#define lua_assert(c) ((void)0) ------------------ 693| 295k| othern = mainpositionfromnode(t, mp); 694| 295k| if (othern != mp) { /* is colliding node out of its main position? */ ------------------ | Branch (694:9): [True: 57.7k, False: 237k] ------------------ 695| | /* yes; move colliding node into free position */ 696| 77.6k| while (othern + gnext(othern) != mp) /* find previous */ ------------------ | | 15| 77.6k|#define gnext(n) ((n)->u.next) ------------------ | Branch (696:14): [True: 19.9k, False: 57.7k] ------------------ 697| 19.9k| othern += gnext(othern); ------------------ | | 15| 19.9k|#define gnext(n) ((n)->u.next) ------------------ 698| 57.7k| gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */ ------------------ | | 15| 57.7k|#define gnext(n) ((n)->u.next) ------------------ gnext(othern) = cast_int(f - othern); /* rechain to point to 'f' */ ------------------ | | 141| 57.7k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 57.7k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 699| 57.7k| *f = *mp; /* copy colliding node into free pos. (mp->next also goes) */ 700| 57.7k| if (gnext(mp) != 0) { ------------------ | | 15| 57.7k|#define gnext(n) ((n)->u.next) ------------------ | Branch (700:11): [True: 13.1k, False: 44.5k] ------------------ 701| 13.1k| gnext(f) += cast_int(mp - f); /* correct 'next' */ ------------------ | | 15| 13.1k|#define gnext(n) ((n)->u.next) ------------------ gnext(f) += cast_int(mp - f); /* correct 'next' */ ------------------ | | 141| 13.1k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 13.1k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 702| 13.1k| gnext(mp) = 0; /* now 'mp' is free */ ------------------ | | 15| 13.1k|#define gnext(n) ((n)->u.next) ------------------ 703| 13.1k| } 704| 57.7k| setempty(gval(mp)); ------------------ | | 225| 57.7k|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 57.7k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 705| 57.7k| } 706| 237k| else { /* colliding node is in its own main position */ 707| | /* new node will go into free position */ 708| 237k| if (gnext(mp) != 0) ------------------ | | 15| 237k|#define gnext(n) ((n)->u.next) ------------------ | Branch (708:11): [True: 71.9k, False: 165k] ------------------ 709| 71.9k| gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */ ------------------ | | 15| 71.9k|#define gnext(n) ((n)->u.next) ------------------ gnext(f) = cast_int((mp + gnext(mp)) - f); /* chain new position */ ------------------ | | 141| 71.9k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 71.9k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 710| 165k| else lua_assert(gnext(f) == 0); ------------------ | | 114| 165k|#define lua_assert(c) ((void)0) ------------------ 711| 237k| gnext(mp) = cast_int(f - mp); ------------------ | | 15| 237k|#define gnext(n) ((n)->u.next) ------------------ gnext(mp) = cast_int(f - mp); ------------------ | | 141| 237k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 237k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 712| 237k| mp = f; 713| 237k| } 714| 295k| } 715| 686k| setnodekey(L, mp, key); ------------------ | | 714| 686k| { Node *n_=(node); const TValue *io_=(obj); \ | | 715| 686k| n_->u.key_val = io_->value_; n_->u.key_tt = io_->tt_; \ | | 716| 686k| checkliveness(L,io_); } | | ------------------ | | | | 107| 686k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 686k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 686k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 716| 686k| luaC_barrierback(L, obj2gco(t), key); ------------------ | | 185| 686k|#define luaC_barrierback(L,p,v) ( \ | | 186| 686k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 686k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 686k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 686k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 47.0k, False: 639k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 182| 47.0k|#define luaC_objbarrierback(L,p,o) ( \ | | | | 183| 47.0k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 88| 47.0k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 47.0k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 94.1k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 47.0k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 138| 47.0k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 47.0k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 639k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 639k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 717| 686k| lua_assert(isempty(gval(mp))); ------------------ | | 114| 686k|#define lua_assert(c) ((void)0) ------------------ 718| 686k| setobj2t(L, gval(mp), value); ------------------ | | 137| 686k|#define setobj2t setobj | | ------------------ | | | | 119| 686k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 686k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 686k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 686k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 686k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 686k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 686k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 686k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 719| 686k|} luaH_getint: 730| 5.11M|const TValue *luaH_getint (Table *t, lua_Integer key) { 731| 5.11M| if (l_castS2U(key) - 1u < t->alimit) /* 'key' in [1, t->alimit]? */ ------------------ | | 152| 5.11M|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (731:7): [True: 88.6k, False: 5.02M] ------------------ 732| 88.6k| return &t->array[key - 1]; 733| 5.02M| else if (!limitequalsasize(t) && /* key still may be in the array part? */ ------------------ | | 244| 10.0M|#define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 734| 10.0M|#define isrealasize(t) (!((t)->flags & BITRAS)) | | | | ------------------ | | | | | | 733| 5.02M|#define BITRAS (1 << 7) | | | | ------------------ | | | | | Branch (734:25): [True: 3.44M, False: 1.57M] | | | | ------------------ | | ------------------ | | #define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 66| 1.57M|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | | | ------------------ | | | | | Branch (66:19): [True: 1.12M, False: 457k] | | | | ------------------ | | ------------------ ------------------ 734| 5.02M| (l_castS2U(key) == t->alimit + 1 || ------------------ | | 152| 457k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (734:13): [True: 74.2k, False: 383k] ------------------ 735| 457k| l_castS2U(key) - 1u < luaH_realasize(t))) { ------------------ | | 152| 383k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (735:13): [True: 44.1k, False: 339k] ------------------ 736| 118k| t->alimit = cast_uint(key); /* probably '#t' is here now */ ------------------ | | 142| 118k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 118k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 737| 118k| return &t->array[key - 1]; 738| 118k| } 739| 4.90M| else { 740| 4.90M| Node *n = hashint(t, key); 741| 6.58M| for (;;) { /* check whether 'key' is somewhere in the chain */ 742| 6.58M| if (keyisinteger(n) && keyival(n) == key) ------------------ | | 759| 13.1M|#define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 755| 6.58M|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 323| 6.58M|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | | | ------------------ | | | | | | 42| 6.58M|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (759:28): [True: 5.37M, False: 1.21M] | | ------------------ ------------------ if (keyisinteger(n) && keyival(n) == key) ------------------ | | 760| 5.37M|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 756| 5.37M|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ | Branch (742:30): [True: 2.31M, False: 3.06M] ------------------ 743| 2.31M| return gval(n); /* that's it */ ------------------ | | 14| 2.31M|#define gval(n) (&(n)->i_val) ------------------ 744| 4.27M| else { 745| 4.27M| int nx = gnext(n); ------------------ | | 15| 4.27M|#define gnext(n) ((n)->u.next) ------------------ 746| 4.27M| if (nx == 0) break; ------------------ | Branch (746:13): [True: 2.59M, False: 1.67M] ------------------ 747| 1.67M| n += nx; 748| 1.67M| } 749| 6.58M| } 750| 2.59M| return &absentkey; 751| 4.90M| } 752| 5.11M|} luaH_getshortstr: 758| 15.9M|const TValue *luaH_getshortstr (Table *t, TString *key) { 759| 15.9M| Node *n = hashstr(t, key); ------------------ | | 84| 15.9M|#define hashstr(t,str) hashpow2(t, (str)->hash) | | ------------------ | | | | 75| 15.9M|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 15.9M|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 760| 15.9M| lua_assert(key->tt == LUA_VSHRSTR); ------------------ | | 114| 15.9M|#define lua_assert(c) ((void)0) ------------------ 761| 22.3M| for (;;) { /* check whether 'key' is somewhere in the chain */ 762| 22.3M| if (keyisshrstr(n) && eqshrstr(keystrval(n), key)) ------------------ | | 761| 44.7M|#define keyisshrstr(node) (keytt(node) == ctb(LUA_VSHRSTR)) | | ------------------ | | | | 755| 22.3M|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisshrstr(node) (keytt(node) == ctb(LUA_VSHRSTR)) | | ------------------ | | | | 303| 22.3M|#define ctb(t) ((t) | BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 22.3M|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | ------------------ | | | Branch (761:27): [True: 20.2M, False: 2.16M] | | ------------------ ------------------ if (keyisshrstr(n) && eqshrstr(keystrval(n), key)) ------------------ | | 41| 20.2M|#define eqshrstr(a,b) check_exp((a)->tt == LUA_VSHRSTR, (a) == (b)) | | ------------------ | | | | 115| 20.2M|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:25): [True: 15.3M, False: 4.84M] | | | | ------------------ | | ------------------ ------------------ 763| 15.3M| return gval(n); /* that's it */ ------------------ | | 14| 15.3M|#define gval(n) (&(n)->i_val) ------------------ 764| 7.00M| else { 765| 7.00M| int nx = gnext(n); ------------------ | | 15| 7.00M|#define gnext(n) ((n)->u.next) ------------------ 766| 7.00M| if (nx == 0) ------------------ | Branch (766:11): [True: 610k, False: 6.39M] ------------------ 767| 610k| return &absentkey; /* not found */ 768| 6.39M| n += nx; 769| 6.39M| } 770| 22.3M| } 771| 15.9M|} luaH_getstr: 774| 7.54M|const TValue *luaH_getstr (Table *t, TString *key) { 775| 7.54M| if (key->tt == LUA_VSHRSTR) ------------------ | | 360| 7.54M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 7.54M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (775:7): [True: 7.53M, False: 12.2k] ------------------ 776| 7.53M| return luaH_getshortstr(t, key); 777| 12.2k| else { /* for long strings, use generic case */ 778| 12.2k| TValue ko; 779| 12.2k| setsvalue(cast(lua_State *, NULL), &ko, key); ------------------ | | 372| 12.2k| { TValue *io = (obj); TString *x_ = (x); \ | | 373| 12.2k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 72| 12.2k|#define val_(o) ((o)->value_) | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 390| 12.2k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 12.2k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | ------------------ | | | | 114| 12.2k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 374| 12.2k| checkliveness(L,io); } | | ------------------ | | | | 107| 12.2k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 12.2k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 12.2k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 780| 12.2k| return getgeneric(t, &ko, 0); 781| 12.2k| } 782| 7.54M|} luaH_get: 788| 7.96M|const TValue *luaH_get (Table *t, const TValue *key) { 789| 7.96M| switch (ttypetag(key)) { ------------------ | | 84| 7.96M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 7.96M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 790| 7.23M| case LUA_VSHRSTR: return luaH_getshortstr(t, tsvalue(key)); ------------------ | | 360| 7.23M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 7.23M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VSHRSTR: return luaH_getshortstr(t, tsvalue(key)); ------------------ | | 369| 7.23M|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 7.23M|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (790:5): [True: 7.23M, False: 729k] ------------------ 791| 568k| case LUA_VNUMINT: return luaH_getint(t, ivalue(key)); ------------------ | | 323| 568k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 568k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNUMINT: return luaH_getint(t, ivalue(key)); ------------------ | | 333| 568k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 568k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (791:5): [True: 568k, False: 7.39M] ------------------ 792| 0| case LUA_VNIL: return &absentkey; ------------------ | | 183| 0|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (792:5): [True: 0, False: 7.96M] ------------------ 793| 144k| case LUA_VNUMFLT: { ------------------ | | 324| 144k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 144k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (793:5): [True: 144k, False: 7.82M] ------------------ 794| 144k| lua_Integer k; 795| 144k| if (luaV_flttointeger(fltvalue(key), &k, F2Ieq)) /* integral index? */ ------------------ | | 332| 144k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 144k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (795:11): [True: 99.9k, False: 44.1k] ------------------ 796| 99.9k| return luaH_getint(t, k); /* use specialized version */ 797| | /* else... */ 798| 144k| } /* FALLTHROUGH */ 799| 60.3k| default: ------------------ | Branch (799:5): [True: 16.1k, False: 7.95M] ------------------ 800| 60.3k| return getgeneric(t, key, 0); 801| 7.96M| } 802| 7.96M|} luaH_finishset: 812| 1.25M| const TValue *slot, TValue *value) { 813| 1.25M| if (isabstkey(slot)) ------------------ | | 203| 1.25M|#define isabstkey(v) checktag((v), LUA_VABSTKEY) | | ------------------ | | | | 91| 1.25M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 1.25M|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 896k, False: 362k] | | | | ------------------ | | ------------------ ------------------ 814| 896k| luaH_newkey(L, t, key, value); 815| 362k| else 816| 362k| setobj2t(L, cast(TValue *, slot), value); ------------------ | | 137| 362k|#define setobj2t setobj | | ------------------ | | | | 119| 362k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 362k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 362k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 362k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 362k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 362k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 362k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 362k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 817| 1.25M|} luaH_set: 824| 559k|void luaH_set (lua_State *L, Table *t, const TValue *key, TValue *value) { 825| 559k| const TValue *slot = luaH_get(t, key); 826| 559k| luaH_finishset(L, t, key, slot, value); 827| 559k|} luaH_getn: 923| 506k|lua_Unsigned luaH_getn (Table *t) { 924| 506k| unsigned int limit = t->alimit; 925| 506k| if (limit > 0 && isempty(&t->array[limit - 1])) { /* (1)? */ ------------------ | | 217| 505k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 505k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 505k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 505k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 505k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 73.6k, False: 432k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (925:7): [True: 505k, False: 407] ------------------ 926| | /* there must be a boundary before 'limit' */ 927| 73.6k| if (limit >= 2 && !isempty(&t->array[limit - 2])) { ------------------ | | 217| 32|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 32|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 32|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 32|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 32|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (927:9): [True: 32, False: 73.5k] | Branch (927:23): [True: 1, False: 31] ------------------ 928| | /* 'limit - 1' is a boundary; can it be a new limit? */ 929| 1| if (ispow2realasize(t) && !ispow2(limit - 1)) { ------------------ | | 66| 1|#define ispow2(x) (((x) & ((x) - 1)) == 0) ------------------ | Branch (929:11): [True: 1, False: 0] | Branch (929:33): [True: 1, False: 0] ------------------ 930| 1| t->alimit = limit - 1; 931| 1| setnorealasize(t); /* now 'alimit' is not the real size */ ------------------ | | 736| 1|#define setnorealasize(t) ((t)->flags |= BITRAS) | | ------------------ | | | | 733| 1|#define BITRAS (1 << 7) | | ------------------ ------------------ 932| 1| } 933| 1| return limit - 1; 934| 1| } 935| 73.5k| else { /* must search for a boundary in [0, limit] */ 936| 73.5k| unsigned int boundary = binsearch(t->array, 0, limit); 937| | /* can this boundary represent the real size of the array? */ 938| 73.5k| if (ispow2realasize(t) && boundary > luaH_realasize(t) / 2) { ------------------ | Branch (938:11): [True: 73.5k, False: 0] | Branch (938:33): [True: 26, False: 73.5k] ------------------ 939| 26| t->alimit = boundary; /* use it as the new limit */ 940| 26| setnorealasize(t); ------------------ | | 736| 26|#define setnorealasize(t) ((t)->flags |= BITRAS) | | ------------------ | | | | 733| 26|#define BITRAS (1 << 7) | | ------------------ ------------------ 941| 26| } 942| 73.5k| return boundary; 943| 73.5k| } 944| 73.6k| } 945| | /* 'limit' is zero or present in table */ 946| 432k| if (!limitequalsasize(t)) { /* (2)? */ ------------------ | | 244| 432k|#define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 734| 865k|#define isrealasize(t) (!((t)->flags & BITRAS)) | | | | ------------------ | | | | | | 733| 432k|#define BITRAS (1 << 7) | | | | ------------------ | | | | | Branch (734:25): [True: 133k, False: 299k] | | | | ------------------ | | ------------------ | | #define limitequalsasize(t) (isrealasize(t) || ispow2((t)->alimit)) | | ------------------ | | | | 66| 299k|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | | | ------------------ | | | | | Branch (66:19): [True: 50.0k, False: 249k] | | | | ------------------ | | ------------------ ------------------ 947| | /* 'limit' > 0 and array has more elements after 'limit' */ 948| 249k| if (isempty(&t->array[limit])) /* 'limit + 1' is empty? */ ------------------ | | 217| 249k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 249k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 249k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 249k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 249k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 249k, False: 15] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 949| 249k| return limit; /* this is the boundary */ 950| | /* else, try last element in the array */ 951| 15| limit = luaH_realasize(t); 952| 15| if (isempty(&t->array[limit - 1])) { /* empty? */ ------------------ | | 217| 15|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 15|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 15|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 15|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 15|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 15, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 953| | /* there must be a boundary in the array after old limit, 954| | and it must be a valid new limit */ 955| 15| unsigned int boundary = binsearch(t->array, t->alimit, limit); 956| 15| t->alimit = boundary; 957| 15| return boundary; 958| 15| } 959| | /* else, new limit is present in the table; check the hash part */ 960| 15| } 961| | /* (3) 'limit' is the last element and either is zero or present in table */ 962| 183k| lua_assert(limit == luaH_realasize(t) && ------------------ | | 114| 183k|#define lua_assert(c) ((void)0) ------------------ 963| 183k| (limit == 0 || !isempty(&t->array[limit - 1]))); 964| 183k| if (isdummy(t) || isempty(luaH_getint(t, cast(lua_Integer, limit + 1)))) ------------------ | | 27| 366k|#define isdummy(t) ((t)->lastfree == NULL) | | ------------------ | | | Branch (27:21): [True: 1, False: 183k] | | ------------------ ------------------ if (isdummy(t) || isempty(luaH_getint(t, cast(lua_Integer, limit + 1)))) ------------------ | | 217| 183k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 183k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 183k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 183k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 183k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 446, False: 182k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 965| 447| return limit; /* 'limit + 1' is absent */ 966| 182k| else /* 'limit + 1' is also present */ 967| 182k| return hash_search(t, limit); 968| 183k|} ltable.c:arrayindex: 318| 524k|static unsigned int arrayindex (lua_Integer k) { 319| 524k| if (l_castS2U(k) - 1u < MAXASIZE) /* 'k' in [1, MAXASIZE]? */ ------------------ | | 152| 524k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ if (l_castS2U(k) - 1u < MAXASIZE) /* 'k' in [1, MAXASIZE]? */ ------------------ | | 54| 524k|#define MAXASIZE luaM_limitN(1u << MAXABITS, TValue) | | ------------------ | | | | 45| 524k| ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 147| 524k|#define cast_sizet(i) cast(size_t, (i)) | | | | | | ------------------ | | | | | | | | 136| 524k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 41| 524k|#define MAX_SIZET ((size_t)(~(size_t)0)) | | | | ------------------ | | | | | Branch (45:4): [Folded - Ignored] | | | | ------------------ | | | | 46| 524k| cast_uint((MAX_SIZET/sizeof(t)))) | | | | ------------------ | | | | | | 142| 0|#define cast_uint(i) cast(unsigned int, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (319:7): [True: 167k, False: 356k] ------------------ 320| 167k| return cast_uint(k); /* 'key' is an appropriate array index */ ------------------ | | 142| 167k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 167k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 321| 356k| else 322| 356k| return 0; 323| 524k|} ltable.c:setlimittosize: 283| 123k|static unsigned int setlimittosize (Table *t) { 284| 123k| t->alimit = luaH_realasize(t); 285| 123k| setrealasize(t); ------------------ | | 735| 123k|#define setrealasize(t) ((t)->flags &= cast_byte(~BITRAS)) | | ------------------ | | | | 143| 123k|#define cast_byte(i) cast(lu_byte, (i)) | | | | ------------------ | | | | | | 136| 123k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 286| 123k| return t->alimit; 287| 123k|} ltable.c:setnodevector: 480| 242k|static void setnodevector (lua_State *L, Table *t, unsigned int size) { 481| 242k| if (size == 0) { /* no elements to hash part? */ ------------------ | Branch (481:7): [True: 240k, False: 1.91k] ------------------ 482| 240k| t->node = cast(Node *, dummynode); /* use common 'dummynode' */ ------------------ | | 136| 240k|#define cast(t, exp) ((t)(exp)) ------------------ 483| 240k| t->lsizenode = 0; 484| 240k| t->lastfree = NULL; /* signal that it is using dummy node */ 485| 240k| } 486| 1.91k| else { 487| 1.91k| int i; 488| 1.91k| int lsize = luaO_ceillog2(size); 489| 1.91k| if (lsize > MAXHBITS || (1u << lsize) > MAXHSIZE) ------------------ | | 60| 3.83k|#define MAXHBITS (MAXABITS - 1) | | ------------------ | | | | 46| 1.91k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | | | ------------------ | | | | | | 141| 1.91k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 1.91k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (lsize > MAXHBITS || (1u << lsize) > MAXHSIZE) ------------------ | | 68| 1.91k|#define MAXHSIZE luaM_limitN(1u << MAXHBITS, Node) | | ------------------ | | | | 45| 1.91k| ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 147| 1.91k|#define cast_sizet(i) cast(size_t, (i)) | | | | | | ------------------ | | | | | | | | 136| 1.91k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | | | ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) : \ | | | | ------------------ | | | | | | 41| 1.91k|#define MAX_SIZET ((size_t)(~(size_t)0)) | | | | ------------------ | | | | | Branch (45:4): [Folded - Ignored] | | | | ------------------ | | | | 46| 1.91k| cast_uint((MAX_SIZET/sizeof(t)))) | | | | ------------------ | | | | | | 142| 0|#define cast_uint(i) cast(unsigned int, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (489:9): [True: 0, False: 1.91k] | Branch (489:29): [True: 0, False: 1.91k] ------------------ 490| 0| luaG_runerror(L, "table overflow"); 491| 1.91k| size = twoto(lsize); ------------------ | | 792| 1.91k|#define twoto(x) (1<<(x)) ------------------ 492| 1.91k| t->node = luaM_newvector(L, size, Node); ------------------ | | 60| 1.91k|#define luaM_newvector(L,n,t) cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0)) | | ------------------ | | | | 136| 1.91k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 493| 721k| for (i = 0; i < cast_int(size); i++) { ------------------ | | 141| 721k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 721k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (493:17): [True: 719k, False: 1.91k] ------------------ 494| 719k| Node *n = gnode(t, i); ------------------ | | 13| 719k|#define gnode(t,i) (&(t)->node[i]) ------------------ 495| 719k| gnext(n) = 0; ------------------ | | 15| 719k|#define gnext(n) ((n)->u.next) ------------------ 496| 719k| setnilkey(n); ------------------ | | 764| 719k|#define setnilkey(node) (keytt(node) = LUA_TNIL) | | ------------------ | | | | 755| 719k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define setnilkey(node) (keytt(node) = LUA_TNIL) | | ------------------ | | | | 65| 719k|#define LUA_TNIL 0 | | ------------------ ------------------ 497| 719k| setempty(gval(n)); ------------------ | | 225| 719k|#define setempty(v) settt_(v, LUA_VEMPTY) | | ------------------ | | | | 114| 719k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 498| 719k| } 499| 1.91k| t->lsizenode = cast_byte(lsize); ------------------ | | 143| 1.91k|#define cast_byte(i) cast(lu_byte, (i)) | | ------------------ | | | | 136| 1.91k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 500| 1.91k| t->lastfree = gnode(t, size); /* all positions are free */ ------------------ | | 13| 1.91k|#define gnode(t,i) (&(t)->node[i]) ------------------ 501| 1.91k| } 502| 242k|} ltable.c:exchangehashpart: 527| 121k|static void exchangehashpart (Table *t1, Table *t2) { 528| 121k| lu_byte lsizenode = t1->lsizenode; 529| 121k| Node *node = t1->node; 530| 121k| Node *lastfree = t1->lastfree; 531| 121k| t1->lsizenode = t2->lsizenode; 532| 121k| t1->node = t2->node; 533| 121k| t1->lastfree = t2->lastfree; 534| 121k| t2->lsizenode = lsizenode; 535| 121k| t2->node = node; 536| 121k| t2->lastfree = lastfree; 537| 121k|} ltable.c:freehash: 371| 242k|static void freehash (lua_State *L, Table *t) { 372| 242k| if (!isdummy(t)) ------------------ | | 27| 242k|#define isdummy(t) ((t)->lastfree == NULL) ------------------ | Branch (372:7): [True: 1.91k, False: 240k] ------------------ 373| 1.91k| luaM_freearray(L, t->node, cast_sizet(sizenode(t))); ------------------ | | 57| 1.91k|#define luaM_freearray(L, b, n) luaM_free_(L, (b), (n)*sizeof(*(b))) ------------------ 374| 242k|} ltable.c:reinsert: 508| 121k|static void reinsert (lua_State *L, Table *ot, Table *t) { 509| 121k| int j; 510| 121k| int size = sizenode(ot); ------------------ | | 793| 121k|#define sizenode(t) (twoto((t)->lsizenode)) | | ------------------ | | | | 792| 121k|#define twoto(x) (1<<(x)) | | ------------------ ------------------ 511| 799k| for (j = 0; j < size; j++) { ------------------ | Branch (511:15): [True: 678k, False: 121k] ------------------ 512| 678k| Node *old = gnode(ot, j); ------------------ | | 13| 678k|#define gnode(t,i) (&(t)->node[i]) ------------------ 513| 678k| if (!isempty(gval(old))) { ------------------ | | 217| 678k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 678k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 678k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 678k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 678k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (513:9): [True: 557k, False: 120k] ------------------ 514| | /* doesn't need barrier/invalidate cache, as entry was 515| | already present in the table */ 516| 557k| TValue k; 517| 557k| getnodekey(L, &k, old); ------------------ | | 721| 557k| { TValue *io_=(obj); const Node *n_=(node); \ | | 722| 557k| io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \ | | 723| 557k| checkliveness(L,io_); } | | ------------------ | | | | 107| 557k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 557k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 557k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 518| 557k| luaH_set(L, t, &k, gval(old)); ------------------ | | 14| 557k|#define gval(n) (&(n)->i_val) ------------------ 519| 557k| } 520| 678k| } 521| 121k|} ltable.c:mainpositionTV: 151| 1.05M|static Node *mainpositionTV (const Table *t, const TValue *key) { 152| 1.05M| switch (ttypetag(key)) { ------------------ | | 84| 1.05M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 1.05M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 153| 905k| case LUA_VNUMINT: { ------------------ | | 323| 905k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 905k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (153:5): [True: 905k, False: 150k] ------------------ 154| 905k| lua_Integer i = ivalue(key); ------------------ | | 333| 905k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 905k|#define check_exp(c,e) (e) | | ------------------ ------------------ 155| 905k| return hashint(t, i); 156| 0| } 157| 52.2k| case LUA_VNUMFLT: { ------------------ | | 324| 52.2k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 52.2k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (157:5): [True: 52.2k, False: 1.00M] ------------------ 158| 52.2k| lua_Number n = fltvalue(key); ------------------ | | 332| 52.2k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 52.2k|#define check_exp(c,e) (e) | | ------------------ ------------------ 159| 52.2k| return hashmod(t, l_hashfloat(n)); ------------------ | | 81| 52.2k|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | ------------------ | | | | 13| 52.2k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 160| 0| } 161| 62.6k| case LUA_VSHRSTR: { ------------------ | | 360| 62.6k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 62.6k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (161:5): [True: 62.6k, False: 993k] ------------------ 162| 62.6k| TString *ts = tsvalue(key); ------------------ | | 369| 62.6k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 62.6k|#define check_exp(c,e) (e) | | ------------------ ------------------ 163| 62.6k| return hashstr(t, ts); ------------------ | | 84| 62.6k|#define hashstr(t,str) hashpow2(t, (str)->hash) | | ------------------ | | | | 75| 62.6k|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 62.6k|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 164| 0| } 165| 34.3k| case LUA_VLNGSTR: { ------------------ | | 361| 34.3k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 34.3k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (165:5): [True: 34.3k, False: 1.02M] ------------------ 166| 34.3k| TString *ts = tsvalue(key); ------------------ | | 369| 34.3k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 34.3k|#define check_exp(c,e) (e) | | ------------------ ------------------ 167| 34.3k| return hashpow2(t, luaS_hashlongstr(ts)); ------------------ | | 75| 34.3k|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | ------------------ | | | | 13| 34.3k|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 168| 0| } 169| 0| case LUA_VFALSE: ------------------ | | 239| 0|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (169:5): [True: 0, False: 1.05M] ------------------ 170| 0| return hashboolean(t, 0); ------------------ | | 85| 0|#define hashboolean(t,p) hashpow2(t, p) | | ------------------ | | | | 75| 0|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 171| 564| case LUA_VTRUE: ------------------ | | 240| 564|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 564|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (171:5): [True: 564, False: 1.05M] ------------------ 172| 564| return hashboolean(t, 1); ------------------ | | 85| 564|#define hashboolean(t,p) hashpow2(t, p) | | ------------------ | | | | 75| 564|#define hashpow2(t,n) (gnode(t, lmod((n), sizenode(t)))) | | | | ------------------ | | | | | | 13| 564|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 173| 0| case LUA_VLIGHTUSERDATA: { ------------------ | | 429| 0|#define LUA_VLIGHTUSERDATA makevariant(LUA_TLIGHTUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (173:5): [True: 0, False: 1.05M] ------------------ 174| 0| void *p = pvalue(key); ------------------ | | 436| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 175| 0| return hashpointer(t, p); ------------------ | | 88| 0|#define hashpointer(t,p) hashmod(t, point2uint(p)) | | ------------------ | | | | 81| 0|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | | | ------------------ | | | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 176| 0| } 177| 0| case LUA_VLCF: { ------------------ | | 591| 0|#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (177:5): [True: 0, False: 1.05M] ------------------ 178| 0| lua_CFunction f = fvalue(key); ------------------ | | 605| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 179| 0| return hashpointer(t, f); ------------------ | | 88| 0|#define hashpointer(t,p) hashmod(t, point2uint(p)) | | ------------------ | | | | 81| 0|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | | | ------------------ | | | | | | 13| 0|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 180| 0| } 181| 657| default: { ------------------ | Branch (181:5): [True: 657, False: 1.05M] ------------------ 182| 657| GCObject *o = gcvalue(key); ------------------ | | 305| 657|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 657|#define check_exp(c,e) (e) | | ------------------ ------------------ 183| 657| return hashpointer(t, o); ------------------ | | 88| 657|#define hashpointer(t,p) hashmod(t, point2uint(p)) | | ------------------ | | | | 81| 657|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | | | ------------------ | | | | | | 13| 657|#define gnode(t,i) (&(t)->node[i]) | | | | ------------------ | | ------------------ ------------------ 184| 0| } 185| 1.05M| } 186| 1.05M|} ltable.c:l_hashfloat: 131| 52.2k|static int l_hashfloat (lua_Number n) { 132| 52.2k| int i; 133| 52.2k| lua_Integer ni; 134| 52.2k| n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN); ------------------ | | 473| 52.2k|#define l_mathop(op) op ------------------ n = l_mathop(frexp)(n, &i) * -cast_num(INT_MIN); ------------------ | | 140| 52.2k|#define cast_num(i) cast(lua_Number, (i)) | | ------------------ | | | | 136| 52.2k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 135| 52.2k| if (!lua_numbertointeger(n, &ni)) { /* is 'n' inf/-inf/NaN? */ ------------------ | | 424| 52.2k| ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 546| 52.2k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (424:4): [True: 52.1k, False: 22] | | ------------------ | | 425| 52.2k| (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 546| 52.1k|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (425:4): [True: 50.9k, False: 1.23k] | | ------------------ | | 426| 52.2k| (*(p) = (LUA_INTEGER)(n), 1)) | | ------------------ | | | Branch (426:7): [True: 50.9k, False: 0] | | ------------------ ------------------ 136| 1.25k| lua_assert(luai_numisnan(n) || l_mathop(fabs)(n) == cast_num(HUGE_VAL)); ------------------ | | 114| 1.25k|#define lua_assert(c) ((void)0) ------------------ 137| 1.25k| return 0; 138| 1.25k| } 139| 50.9k| else { /* normal case */ 140| 50.9k| unsigned int u = cast_uint(i) + cast_uint(ni); ------------------ | | 142| 50.9k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 50.9k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ unsigned int u = cast_uint(i) + cast_uint(ni); ------------------ | | 142| 50.9k|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 50.9k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 141| 50.9k| return cast_int(u <= cast_uint(INT_MAX) ? u : ~u); ------------------ | | 141| 50.9k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 101k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 47.5k, False: 3.37k] | | | | ------------------ | | ------------------ ------------------ 142| 50.9k| } 143| 52.2k|} ltable.c:getfreepos: 645| 297k|static Node *getfreepos (Table *t) { 646| 297k| if (!isdummy(t)) { ------------------ | | 27| 297k|#define isdummy(t) ((t)->lastfree == NULL) ------------------ | Branch (646:7): [True: 296k, False: 254] ------------------ 647| 615k| while (t->lastfree > t->node) { ------------------ | Branch (647:12): [True: 613k, False: 1.65k] ------------------ 648| 613k| t->lastfree--; 649| 613k| if (keyisnil(t->lastfree)) ------------------ | | 758| 613k|#define keyisnil(node) (keytt(node) == LUA_TNIL) | | ------------------ | | | | 755| 613k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisnil(node) (keytt(node) == LUA_TNIL) | | ------------------ | | | | 65| 613k|#define LUA_TNIL 0 | | ------------------ | | | Branch (758:25): [True: 295k, False: 318k] | | ------------------ ------------------ 650| 295k| return t->lastfree; 651| 613k| } 652| 296k| } 653| 1.90k| return NULL; /* could not find a free place */ 654| 297k|} ltable.c:rehash: 598| 1.90k|static void rehash (lua_State *L, Table *t, const TValue *ek) { 599| 1.90k| unsigned int asize; /* optimal size for array part */ 600| 1.90k| unsigned int na; /* number of keys in the array part */ 601| 1.90k| unsigned int nums[MAXABITS + 1]; 602| 1.90k| int i; 603| 1.90k| int totaluse; 604| 62.9k| for (i = 0; i <= MAXABITS; i++) nums[i] = 0; /* reset counts */ ------------------ | | 46| 62.9k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | ------------------ | | | | 141| 62.9k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 62.9k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (604:15): [True: 61.0k, False: 1.90k] ------------------ 605| 1.90k| setlimittosize(t); 606| 1.90k| na = numusearray(t, nums); /* count keys in array part */ 607| 1.90k| totaluse = na; /* all those keys are integer keys */ 608| 1.90k| totaluse += numusehash(t, nums, &na); /* count keys in hash part */ 609| | /* count extra key */ 610| 1.90k| if (ttisinteger(ek)) ------------------ | | 328| 1.90k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 1.90k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 1.90k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 288, False: 1.62k] | | | | ------------------ | | ------------------ ------------------ 611| 288| na += countint(ivalue(ek), nums); ------------------ | | 333| 288|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 288|#define check_exp(c,e) (e) | | ------------------ ------------------ 612| 1.90k| totaluse++; 613| | /* compute new size for array part */ 614| 1.90k| asize = computesizes(nums, &na); 615| | /* resize the table to new computed sizes */ 616| 1.90k| luaH_resize(L, t, asize, totaluse - na); 617| 1.90k|} ltable.c:numusearray: 429| 1.90k|static unsigned int numusearray (const Table *t, unsigned int *nums) { 430| 1.90k| int lg; 431| 1.90k| unsigned int ttlg; /* 2^lg */ 432| 1.90k| unsigned int ause = 0; /* summation of 'nums' */ 433| 1.90k| unsigned int i = 1; /* count to traverse all array keys */ 434| 1.90k| unsigned int asize = limitasasize(t); /* real array size */ ------------------ | | 290| 1.90k|#define limitasasize(t) check_exp(isrealasize(t), t->alimit) | | ------------------ | | | | 115| 1.90k|#define check_exp(c,e) (e) | | ------------------ ------------------ 435| | /* traverse each slice */ 436| 3.07k| for (lg = 0, ttlg = 1; lg <= MAXABITS; lg++, ttlg *= 2) { ------------------ | | 46| 3.07k|#define MAXABITS cast_int(sizeof(int) * CHAR_BIT - 1) | | ------------------ | | | | 141| 3.07k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 3.07k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (436:26): [True: 3.07k, False: 0] ------------------ 437| 3.07k| unsigned int lc = 0; /* counter */ 438| 3.07k| unsigned int lim = ttlg; 439| 3.07k| if (lim > asize) { ------------------ | Branch (439:9): [True: 1.90k, False: 1.17k] ------------------ 440| 1.90k| lim = asize; /* adjust upper limit */ 441| 1.90k| if (i > lim) ------------------ | Branch (441:11): [True: 1.90k, False: 0] ------------------ 442| 1.90k| break; /* no more elements to count */ 443| 1.90k| } 444| | /* count elements in range (2^(lg - 1), 2^lg] */ 445| 2.31M| for (; i <= lim; i++) { ------------------ | Branch (445:12): [True: 2.31M, False: 1.17k] ------------------ 446| 2.31M| if (!isempty(&t->array[i-1])) ------------------ | | 217| 2.31M|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 2.31M|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 2.31M|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 2.31M|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 2.31M|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (446:11): [True: 1.88M, False: 434k] ------------------ 447| 1.88M| lc++; 448| 2.31M| } 449| 1.17k| nums[lg] += lc; 450| 1.17k| ause += lc; 451| 1.17k| } 452| 1.90k| return ause; 453| 1.90k|} ltable.c:numusehash: 456| 1.90k|static int numusehash (const Table *t, unsigned int *nums, unsigned int *pna) { 457| 1.90k| int totaluse = 0; /* total number of elements */ 458| 1.90k| int ause = 0; /* elements added to 'nums' (can go to array part) */ 459| 1.90k| int i = sizenode(t); ------------------ | | 793| 1.90k|#define sizenode(t) (twoto((t)->lsizenode)) | | ------------------ | | | | 792| 1.90k|#define twoto(x) (1<<(x)) | | ------------------ ------------------ 460| 560k| while (i--) { ------------------ | Branch (460:10): [True: 558k, False: 1.90k] ------------------ 461| 558k| Node *n = &t->node[i]; 462| 558k| if (!isempty(gval(n))) { ------------------ | | 217| 558k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 558k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 558k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 558k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 558k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (462:9): [True: 557k, False: 355] ------------------ 463| 557k| if (keyisinteger(n)) ------------------ | | 759| 557k|#define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 755| 557k|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisinteger(node) (keytt(node) == LUA_VNUMINT) | | ------------------ | | | | 323| 557k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | | | ------------------ | | | | | | 42| 557k|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (759:28): [True: 523k, False: 33.9k] | | ------------------ ------------------ 464| 523k| ause += countint(keyival(n), nums); ------------------ | | 760| 523k|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 756| 523k|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ 465| 557k| totaluse++; 466| 557k| } 467| 558k| } 468| 1.90k| *pna += ause; 469| 1.90k| return totaluse; 470| 1.90k|} ltable.c:countint: 413| 524k|static int countint (lua_Integer key, unsigned int *nums) { 414| 524k| unsigned int k = arrayindex(key); 415| 524k| if (k != 0) { /* is 'key' an appropriate array index? */ ------------------ | Branch (415:7): [True: 167k, False: 356k] ------------------ 416| 167k| nums[luaO_ceillog2(k)]++; /* count as such */ 417| 167k| return 1; 418| 167k| } 419| 356k| else 420| 356k| return 0; 421| 524k|} ltable.c:computesizes: 391| 1.90k|static unsigned int computesizes (unsigned int nums[], unsigned int *pna) { 392| 1.90k| int i; 393| 1.90k| unsigned int twotoi; /* 2^i (candidate for optimal size) */ 394| 1.90k| unsigned int a = 0; /* number of elements smaller than 2^i */ 395| 1.90k| unsigned int na = 0; /* number of elements to go to array part */ 396| 1.90k| unsigned int optimal = 0; /* optimal size for array part */ 397| | /* loop while keys can fill more than half of total size */ 398| 1.90k| for (i = 0, twotoi = 1; 399| 5.31k| twotoi > 0 && *pna > twotoi / 2; ------------------ | Branch (399:8): [True: 5.31k, False: 0] | Branch (399:22): [True: 3.40k, False: 1.90k] ------------------ 400| 3.40k| i++, twotoi *= 2) { 401| 3.40k| a += nums[i]; 402| 3.40k| if (a > twotoi/2) { /* more than half elements present? */ ------------------ | Branch (402:9): [True: 1.50k, False: 1.89k] ------------------ 403| 1.50k| optimal = twotoi; /* optimal size (till now) */ 404| 1.50k| na = a; /* all elements up to 'optimal' will go to array part */ 405| 1.50k| } 406| 3.40k| } 407| 1.90k| lua_assert((optimal == 0 || optimal / 2 < na) && na <= optimal); ------------------ | | 114| 1.90k|#define lua_assert(c) ((void)0) ------------------ 408| 1.90k| *pna = na; 409| 1.90k| return optimal; 410| 1.90k|} ltable.c:mainpositionfromnode: 189| 295k|l_sinline Node *mainpositionfromnode (const Table *t, Node *nd) { 190| 295k| TValue key; 191| 295k| getnodekey(cast(lua_State *, NULL), &key, nd); ------------------ | | 721| 295k| { TValue *io_=(obj); const Node *n_=(node); \ | | 722| 295k| io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \ | | 723| 295k| checkliveness(L,io_); } | | ------------------ | | | | 107| 295k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 295k|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 295k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ ------------------ 192| 295k| return mainpositionTV(t, &key); 193| 295k|} ltable.c:hashint: 108| 5.81M|static Node *hashint (const Table *t, lua_Integer i) { 109| 5.81M| lua_Unsigned ui = l_castS2U(i); ------------------ | | 152| 5.81M|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 110| 5.81M| if (ui <= cast_uint(INT_MAX)) ------------------ | | 142| 5.81M|#define cast_uint(i) cast(unsigned int, (i)) | | ------------------ | | | | 136| 5.81M|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ | Branch (110:7): [True: 4.67M, False: 1.14M] ------------------ 111| 4.67M| return hashmod(t, cast_int(ui)); ------------------ | | 81| 4.67M|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | ------------------ | | | | 13| 4.67M|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 112| 1.14M| else 113| 1.14M| return hashmod(t, ui); ------------------ | | 81| 1.14M|#define hashmod(t,n) (gnode(t, ((n) % ((sizenode(t)-1)|1)))) | | ------------------ | | | | 13| 1.14M|#define gnode(t,i) (&(t)->node[i]) | | ------------------ ------------------ 114| 5.81M|} ltable.c:getgeneric: 299| 72.6k|static const TValue *getgeneric (Table *t, const TValue *key, int deadok) { 300| 72.6k| Node *n = mainpositionTV(t, key); 301| 102k| for (;;) { /* check whether 'key' is somewhere in the chain */ 302| 102k| if (equalkey(key, n, deadok)) ------------------ | Branch (302:9): [True: 62.2k, False: 39.9k] ------------------ 303| 62.2k| return gval(n); /* that's it */ ------------------ | | 14| 62.2k|#define gval(n) (&(n)->i_val) ------------------ 304| 39.9k| else { 305| 39.9k| int nx = gnext(n); ------------------ | | 15| 39.9k|#define gnext(n) ((n)->u.next) ------------------ 306| 39.9k| if (nx == 0) ------------------ | Branch (306:11): [True: 10.4k, False: 29.4k] ------------------ 307| 10.4k| return &absentkey; /* not found */ 308| 29.4k| n += nx; 309| 29.4k| } 310| 102k| } 311| 72.6k|} ltable.c:equalkey: 216| 102k|static int equalkey (const TValue *k1, const Node *n2, int deadok) { 217| 102k| if ((rawtt(k1) != keytt(n2)) && /* not the same variants? */ ------------------ | | 77| 102k|#define rawtt(o) ((o)->tt_) ------------------ if ((rawtt(k1) != keytt(n2)) && /* not the same variants? */ ------------------ | | 755| 102k|#define keytt(node) ((node)->u.key_tt) ------------------ | Branch (217:7): [True: 33.5k, False: 68.6k] ------------------ 218| 102k| !(deadok && keyisdead(n2) && iscollectable(k1))) ------------------ | | 779| 33.5k|#define keyisdead(node) (keytt(node) == LUA_TDEADKEY) | | ------------------ | | | | 755| 0|#define keytt(node) ((node)->u.key_tt) | | ------------------ | | #define keyisdead(node) (keytt(node) == LUA_TDEADKEY) | | ------------------ | | | | 24| 0|#define LUA_TDEADKEY (LUA_NUMTYPES+2) /* removed keys in tables */ | | | | ------------------ | | | | | | 75| 0|#define LUA_NUMTYPES 9 | | | | ------------------ | | ------------------ | | | Branch (779:26): [True: 0, False: 0] | | ------------------ ------------------ !(deadok && keyisdead(n2) && iscollectable(k1))) ------------------ | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | ------------------ | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | ------------------ | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ | | | Branch (300:26): [True: 0, False: 0] | | ------------------ ------------------ | Branch (218:10): [True: 0, False: 33.5k] ------------------ 219| 33.5k| return 0; /* cannot be same key */ 220| 68.6k| switch (keytt(n2)) { ------------------ | | 755| 68.6k|#define keytt(node) ((node)->u.key_tt) ------------------ 221| 155| case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: ------------------ | | 183| 0|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: ------------------ | | 239| 0|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: ------------------ | | 240| 155|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 155|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (221:5): [True: 0, False: 68.6k] | Branch (221:20): [True: 0, False: 68.6k] | Branch (221:37): [True: 155, False: 68.5k] ------------------ 222| 155| return 1; 223| 0| case LUA_VNUMINT: ------------------ | | 323| 0|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (223:5): [True: 0, False: 68.6k] ------------------ 224| 0| return (ivalue(k1) == keyival(n2)); ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ return (ivalue(k1) == keyival(n2)); ------------------ | | 760| 0|#define keyival(node) (keyval(node).i) | | ------------------ | | | | 756| 0|#define keyval(node) ((node)->u.key_val) | | ------------------ ------------------ 225| 41.1k| case LUA_VNUMFLT: ------------------ | | 324| 41.1k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 41.1k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (225:5): [True: 41.1k, False: 27.4k] ------------------ 226| 41.1k| return luai_numeq(fltvalue(k1), fltvalueraw(keyval(n2))); ------------------ | | 350| 41.1k|#define luai_numeq(a,b) ((a)==(b)) ------------------ 227| 0| case LUA_VLIGHTUSERDATA: ------------------ | | 429| 0|#define LUA_VLIGHTUSERDATA makevariant(LUA_TLIGHTUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (227:5): [True: 0, False: 68.6k] ------------------ 228| 0| return pvalue(k1) == pvalueraw(keyval(n2)); ------------------ | | 436| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ return pvalue(k1) == pvalueraw(keyval(n2)); ------------------ | | 439| 0|#define pvalueraw(v) ((v).p) ------------------ 229| 0| case LUA_VLCF: ------------------ | | 591| 0|#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (229:5): [True: 0, False: 68.6k] ------------------ 230| 0| return fvalue(k1) == fvalueraw(keyval(n2)); ------------------ | | 605| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ return fvalue(k1) == fvalueraw(keyval(n2)); ------------------ | | 608| 0|#define fvalueraw(v) ((v).f) ------------------ 231| 26.9k| case ctb(LUA_VLNGSTR): ------------------ | | 303| 26.9k|#define ctb(t) ((t) | BIT_ISCOLLECTABLE) | | ------------------ | | | | 298| 26.9k|#define BIT_ISCOLLECTABLE (1 << 6) | | ------------------ ------------------ | Branch (231:5): [True: 26.9k, False: 41.7k] ------------------ 232| 26.9k| return luaS_eqlngstr(tsvalue(k1), keystrval(n2)); ------------------ | | 369| 26.9k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 26.9k|#define check_exp(c,e) (e) | | ------------------ ------------------ return luaS_eqlngstr(tsvalue(k1), keystrval(n2)); ------------------ | | 762| 26.9k|#define keystrval(node) (gco2ts(keyval(node).gc)) | | ------------------ | | | | 374| 26.9k| check_exp(novariant((o)->tt) == LUA_TSTRING, &((cast_u(o))->ts)) | | | | ------------------ | | | | | | 115| 26.9k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 233| 391| default: ------------------ | Branch (233:5): [True: 391, False: 68.2k] ------------------ 234| 391| return gcvalue(k1) == gcvalueraw(keyval(n2)); ------------------ | | 305| 391|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 391|#define check_exp(c,e) (e) | | ------------------ ------------------ return gcvalue(k1) == gcvalueraw(keyval(n2)); ------------------ | | 307| 391|#define gcvalueraw(v) ((v).gc) ------------------ 235| 68.6k| } 236| 68.6k|} ltable.c:ispow2realasize: 278| 73.6k|static int ispow2realasize (const Table *t) { 279| 73.6k| return (!isrealasize(t) || ispow2(t->alimit)); ------------------ | | 734| 147k|#define isrealasize(t) (!((t)->flags & BITRAS)) | | ------------------ | | | | 733| 73.6k|#define BITRAS (1 << 7) | | ------------------ ------------------ return (!isrealasize(t) || ispow2(t->alimit)); ------------------ | | 66| 73.6k|#define ispow2(x) (((x) & ((x) - 1)) == 0) | | ------------------ | | | Branch (66:19): [True: 73.6k, False: 0] | | ------------------ ------------------ | Branch (279:11): [True: 0, False: 73.6k] ------------------ 280| 73.6k|} ltable.c:binsearch: 881| 73.6k| unsigned int j) { 882| 74.1k| while (j - i > 1u) { /* binary search */ ------------------ | Branch (882:10): [True: 540, False: 73.6k] ------------------ 883| 540| unsigned int m = (i + j) / 2; 884| 540| if (isempty(&array[m - 1])) j = m; ------------------ | | 217| 540|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 540|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 540|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 540|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 540|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 307, False: 233] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 885| 233| else i = m; 886| 540| } 887| 73.6k| return i; 888| 73.6k|} ltable.c:hash_search: 855| 182k|static lua_Unsigned hash_search (Table *t, lua_Unsigned j) { 856| 182k| lua_Unsigned i; 857| 182k| if (j == 0) j++; /* the caller ensures 'j + 1' is present */ ------------------ | Branch (857:7): [True: 9, False: 182k] ------------------ 858| 182k| do { 859| 182k| i = j; /* 'i' is a present index */ 860| 182k| if (j <= l_castS2U(LUA_MAXINTEGER) / 2) ------------------ | | 152| 182k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ | Branch (860:9): [True: 182k, False: 0] ------------------ 861| 182k| j *= 2; 862| 0| else { 863| 0| j = LUA_MAXINTEGER; ------------------ | | 545| 0|#define LUA_MAXINTEGER LLONG_MAX ------------------ 864| 0| if (isempty(luaH_getint(t, j))) /* t[j] not present? */ ------------------ | | 217| 0|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 865| 0| break; /* 'j' now is an absent index */ 866| 0| else /* weird case */ 867| 0| return j; /* well, max integer is a boundary... */ 868| 0| } 869| 182k| } while (!isempty(luaH_getint(t, j))); /* repeat until an absent t[j] */ ------------------ | | 217| 182k|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 182k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 182k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 182k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 182k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (869:12): [True: 14, False: 182k] ------------------ 870| | /* i < j && t[i] present && t[j] absent */ 871| 3.26M| while (j - i > 1u) { /* do a binary search between them */ ------------------ | Branch (871:10): [True: 3.07M, False: 182k] ------------------ 872| 3.07M| lua_Unsigned m = (i + j) / 2; 873| 3.07M| if (isempty(luaH_getint(t, m))) j = m; ------------------ | | 217| 3.07M|#define isempty(v) ttisnil(v) | | ------------------ | | | | 193| 3.07M|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 3.07M|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 3.07M|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 3.07M|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 1.69M, False: 1.37M] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 874| 1.37M| else i = m; 875| 3.07M| } 876| 182k| return i; 877| 182k|} luaT_init: 38| 258|void luaT_init (lua_State *L) { 39| 258| static const char *const luaT_eventname[] = { /* ORDER TM */ 40| 258| "__index", "__newindex", 41| 258| "__gc", "__mode", "__len", "__eq", 42| 258| "__add", "__sub", "__mul", "__mod", "__pow", 43| 258| "__div", "__idiv", 44| 258| "__band", "__bor", "__bxor", "__shl", "__shr", 45| 258| "__unm", "__bnot", "__lt", "__le", 46| 258| "__concat", "__call", "__close" 47| 258| }; 48| 258| int i; 49| 6.70k| for (i=0; itmname[i] = luaS_new(L, luaT_eventname[i]); ------------------ | | 335| 6.45k|#define G(L) (L->l_G) ------------------ 51| 6.45k| luaC_fix(L, obj2gco(G(L)->tmname[i])); /* never collect these names */ ------------------ | | 390| 6.45k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | ------------------ | | | | 115| 6.45k|#define check_exp(c,e) (e) | | ------------------ ------------------ 52| 6.45k| } 53| 258|} luaT_gettm: 60| 11|const TValue *luaT_gettm (Table *events, TMS event, TString *ename) { 61| 11| const TValue *tm = luaH_getshortstr(events, ename); 62| 11| lua_assert(event <= TM_EQ); ------------------ | | 114| 11|#define lua_assert(c) ((void)0) ------------------ 63| 11| if (notm(tm)) { /* no tag method? */ ------------------ | | 62| 11|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 193| 11|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 11|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 11|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 11|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 11] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 64| 0| events->flags |= cast_byte(1u<metatable; ------------------ | | 684| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 76| 0| break; 77| 33| case LUA_TUSERDATA: ------------------ | | 72| 33|#define LUA_TUSERDATA 7 ------------------ | Branch (77:5): [True: 33, False: 62] ------------------ 78| 33| mt = uvalue(o)->metatable; ------------------ | | 437| 33|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 115| 33|#define check_exp(c,e) (e) | | ------------------ ------------------ 79| 33| break; 80| 62| default: ------------------ | Branch (80:5): [True: 62, False: 33] ------------------ 81| 62| mt = G(L)->mt[ttype(o)]; ------------------ | | 335| 62|#define G(L) (L->l_G) ------------------ mt = G(L)->mt[ttype(o)]; ------------------ | | 87| 62|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 62|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ 82| 95| } 83| 95| return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : &G(L)->nilvalue); ------------------ | | 335| 33|#define G(L) (L->l_G) ------------------ return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : &G(L)->nilvalue); ------------------ | | 335| 62|#define G(L) (L->l_G) ------------------ | Branch (83:11): [True: 33, False: 62] ------------------ 84| 95|} luaT_objtypename: 91| 38|const char *luaT_objtypename (lua_State *L, const TValue *o) { 92| 38| Table *mt; 93| 38| if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) || ------------------ | | 682| 38|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | ------------------ | | | | 91| 76|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 38|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 38] | | | | ------------------ | | ------------------ ------------------ if ((ttistable(o) && (mt = hvalue(o)->metatable) != NULL) || ------------------ | | 684| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (93:24): [True: 0, False: 0] ------------------ 94| 38| (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) { ------------------ | | 434| 38|#define ttisfulluserdata(o) checktag((o), ctb(LUA_VUSERDATA)) | | ------------------ | | | | 91| 76|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 38|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 38] | | | | ------------------ | | ------------------ ------------------ (ttisfulluserdata(o) && (mt = uvalue(o)->metatable) != NULL)) { ------------------ | | 437| 0|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (94:31): [True: 0, False: 0] ------------------ 95| 0| const TValue *name = luaH_getshortstr(mt, luaS_new(L, "__name")); 96| 0| if (ttisstring(name)) /* is '__name' a string? */ ------------------ | | 363| 0|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 97| 0| return getstr(tsvalue(name)); /* use it as type name */ ------------------ | | 403| 0|#define getstr(ts) ((ts)->contents) ------------------ 98| 0| } 99| 38| return ttypename(ttype(o)); /* else use standard type name */ ------------------ | | 70| 38|#define ttypename(x) luaT_typenames_[(x) + 1] ------------------ 100| 38|} luaT_trybinTM: 149| 28| StkId res, TMS event) { 150| 28| if (l_unlikely(!callbinTM(L, p1, p2, res, event))) { ------------------ | | 688| 28|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 28|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 28, False: 0] | | | | ------------------ | | ------------------ ------------------ 151| 28| switch (event) { 152| 13| case TM_BAND: case TM_BOR: case TM_BXOR: ------------------ | Branch (152:7): [True: 13, False: 15] | Branch (152:21): [True: 0, False: 28] | Branch (152:34): [True: 0, False: 28] ------------------ 153| 20| case TM_SHL: case TM_SHR: case TM_BNOT: { ------------------ | Branch (153:7): [True: 0, False: 28] | Branch (153:20): [True: 0, False: 28] | Branch (153:33): [True: 7, False: 21] ------------------ 154| 20| if (ttisnumber(p1) && ttisnumber(p2)) ------------------ | | 326| 20|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | ------------------ | | | | 92| 40|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 20|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 20|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 20] | | | | ------------------ | | ------------------ ------------------ if (ttisnumber(p1) && ttisnumber(p2)) ------------------ | | 326| 0|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | ------------------ | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 155| 0| luaG_tointerror(L, p1, p2); 156| 20| else 157| 20| luaG_opinterror(L, p1, p2, "perform bitwise operation on"); 158| 20| } 159| | /* calls never return, but to avoid warnings: *//* FALLTHROUGH */ 160| 8| default: ------------------ | Branch (160:7): [True: 8, False: 20] ------------------ 161| 8| luaG_opinterror(L, p1, p2, "perform arithmetic on"); 162| 28| } 163| 28| } 164| 28|} luaT_callorderTM: 202| 1| TMS event) { 203| 1| if (callbinTM(L, p1, p2, L->top.p, event)) /* try original event */ ------------------ | Branch (203:7): [True: 0, False: 1] ------------------ 204| 0| return !l_isfalse(s2v(L->top.p)); ------------------ | | 247| 0|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 0|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 205| |#if defined(LUA_COMPAT_LT_LE) 206| | else if (event == TM_LE) { 207| | /* try '!(p2 < p1)' for '(p1 <= p2)' */ 208| | L->ci->callstatus |= CIST_LEQ; /* mark it is doing 'lt' for 'le' */ 209| | if (callbinTM(L, p2, p1, L->top.p, TM_LT)) { 210| | L->ci->callstatus ^= CIST_LEQ; /* clear mark */ 211| | return l_isfalse(s2v(L->top.p)); 212| | } 213| | /* else error will remove this 'ci'; no need to clear mark */ 214| | } 215| |#endif 216| 1| luaG_ordererror(L, p1, p2); /* no metamethod found */ 217| 0| return 0; /* to avoid warnings */ 218| 1|} luaT_adjustvarargs: 239| 1.34k| const Proto *p) { 240| 1.34k| int i; 241| 1.34k| int actual = cast_int(L->top.p - ci->func.p) - 1; /* number of arguments */ ------------------ | | 141| 1.34k|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 1.34k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 242| 1.34k| int nextra = actual - nfixparams; /* number of extra arguments */ 243| 1.34k| ci->u.l.nextraargs = nextra; 244| 1.34k| luaD_checkstack(L, p->maxstacksize + 1); ------------------ | | 32| 1.34k|#define luaD_checkstack(L,n) luaD_checkstackaux(L,n,(void)0,(void)0) | | ------------------ | | | | 27| 1.34k| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 688| 1.34k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 1.34k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 2, False: 1.34k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 1.34k| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | 29| 1.34k| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 1.34k|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ ------------------ 245| | /* copy function to the top of the stack */ 246| 1.34k| setobjs2s(L, L->top.p++, ci->func.p); ------------------ | | 129| 1.34k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 1.34k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 1.34k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 1.34k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 1.34k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 1.34k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 1.34k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 1.34k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 1.34k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 247| | /* move fixed parameters to the top of the stack */ 248| 3.96k| for (i = 1; i <= nfixparams; i++) { ------------------ | Branch (248:15): [True: 2.61k, False: 1.34k] ------------------ 249| 2.61k| setobjs2s(L, L->top.p++, ci->func.p + i); ------------------ | | 129| 2.61k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 2.61k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 2.61k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 2.61k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 2.61k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 2.61k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 2.61k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 2.61k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 2.61k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 250| 2.61k| setnilvalue(s2v(ci->func.p + i)); /* erase original parameter (for GC) */ ------------------ | | 200| 2.61k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 2.61k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 251| 2.61k| } 252| 1.34k| ci->func.p += actual + 1; 253| 1.34k| ci->top.p += actual + 1; 254| 1.34k| lua_assert(L->top.p <= ci->top.p && ci->top.p <= L->stack_last.p); ------------------ | | 114| 1.34k|#define lua_assert(c) ((void)0) ------------------ 255| 1.34k|} luaT_getvarargs: 258| 203k|void luaT_getvarargs (lua_State *L, CallInfo *ci, StkId where, int wanted) { 259| 203k| int i; 260| 203k| int nextra = ci->u.l.nextraargs; 261| 203k| if (wanted < 0) { ------------------ | Branch (261:7): [True: 1.30k, False: 202k] ------------------ 262| 1.30k| wanted = nextra; /* get all extra arguments available */ 263| 1.30k| checkstackGCp(L, nextra, where); /* ensure stack space */ ------------------ | | 49| 1.30k| luaD_checkstackaux(L, n, \ | | ------------------ | | | | 27| 1.30k| if (l_unlikely(L->stack_last.p - L->top.p <= (n))) \ | | | | ------------------ | | | | | | 688| 1.30k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 1.30k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 7, False: 1.30k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 28| 1.30k| { pre; luaD_growstack(L, n, 1); pos; } \ | | | | ------------------ | | | | | Branch (28:6): [True: 3, False: 4] | | | | ------------------ | | | | 29| 1.30k| else { condmovestack(L,pre,pos); } | | | | ------------------ | | | | | | 366| 1.30k|#define condmovestack(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 50| 1.30k| ptrdiff_t t__ = savestack(L, p); /* save 'p' */ \ | | 51| 1.30k| luaC_checkGC(L), /* stack grow uses memory */ \ | | 52| 1.30k| p = restorestack(L, t__)) /* 'pos' part: restore 'p' */ ------------------ 264| 1.30k| L->top.p = where + nextra; /* next instruction will need top */ 265| 1.30k| } 266| 1.05M| for (i = 0; i < wanted && i < nextra; i++) ------------------ | Branch (266:15): [True: 970k, False: 84.0k] | Branch (266:29): [True: 850k, False: 119k] ------------------ 267| 850k| setobjs2s(L, where + i, ci->func.p - nextra + i); ------------------ | | 129| 850k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 850k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 850k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 850k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 850k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 850k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 850k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 850k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 850k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 268| 323k| for (; i < wanted; i++) /* complete required results with nil */ ------------------ | Branch (268:10): [True: 119k, False: 203k] ------------------ 269| 203k| setnilvalue(s2v(where + i)); ------------------ | | 200| 119k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 119k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 270| 203k|} ltm.c:callbinTM: 138| 29| StkId res, TMS event) { 139| 29| const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */ 140| 29| if (notm(tm)) ------------------ | | 62| 29|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 193| 29|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 29|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 29|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 29|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 29, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 141| 29| tm = luaT_gettmbyobj(L, p2, event); /* try second operand */ 142| 29| if (notm(tm)) return 0; ------------------ | | 62| 29|#define notm(tm) ttisnil(tm) | | ------------------ | | | | 193| 29|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 29|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 29|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 29|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 29, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 143| 0| luaT_callTMres(L, tm, p1, p2, res); 144| 0| return 1; 145| 29|} luaV_tonumber_: 103| 5|int luaV_tonumber_ (const TValue *obj, lua_Number *n) { 104| 5| TValue v; 105| 5| if (ttisinteger(obj)) { ------------------ | | 328| 5|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 5|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 5|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 5] | | | | ------------------ | | ------------------ ------------------ 106| 0| *n = cast_num(ivalue(obj)); ------------------ | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 107| 0| return 1; 108| 0| } 109| 5| else if (l_strton(obj, &v)) { /* string coercible to number? */ ------------------ | Branch (109:12): [True: 0, False: 5] ------------------ 110| 0| *n = nvalue(&v); /* convert result of 'luaO_str2num' to a float */ ------------------ | | 330| 0|#define nvalue(o) check_exp(ttisnumber(o), \ | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ | | 331| 0| (ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o))) ------------------ 111| 0| return 1; 112| 0| } 113| 5| else 114| 5| return 0; /* conversion failed */ 115| 5|} luaV_flttointeger: 121| 1.18M|int luaV_flttointeger (lua_Number n, lua_Integer *p, F2Imod mode) { 122| 1.18M| lua_Number f = l_floor(n); ------------------ | | 409| 1.18M|#define l_floor(x) (l_mathop(floor)(x)) | | ------------------ | | | | 473| 1.18M|#define l_mathop(op) op | | ------------------ ------------------ 123| 1.18M| if (n != f) { /* not an integral value? */ ------------------ | Branch (123:7): [True: 82.7k, False: 1.10M] ------------------ 124| 82.7k| if (mode == F2Ieq) return 0; /* fails if mode demands integral value */ ------------------ | Branch (124:9): [True: 82.7k, False: 1] ------------------ 125| 1| else if (mode == F2Iceil) /* needs ceil? */ ------------------ | Branch (125:14): [True: 0, False: 1] ------------------ 126| 0| f += 1; /* convert floor to ceil (remember: n != f) */ 127| 82.7k| } 128| 1.10M| return lua_numbertointeger(f, p); ------------------ | | 424| 1.10M| ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 546| 1.10M|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (424:4): [True: 1.10M, False: 3.78k] | | ------------------ | | 425| 1.10M| (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ | | ------------------ | | | | 546| 1.10M|#define LUA_MININTEGER LLONG_MIN | | ------------------ | | | Branch (425:4): [True: 1.09M, False: 8.09k] | | ------------------ | | 426| 1.10M| (*(p) = (LUA_INTEGER)(n), 1)) | | ------------------ | | | Branch (426:7): [True: 1.09M, False: 0] | | ------------------ ------------------ 129| 1.18M|} luaV_tointegerns: 137| 991k|int luaV_tointegerns (const TValue *obj, lua_Integer *p, F2Imod mode) { 138| 991k| if (ttisfloat(obj)) ------------------ | | 327| 991k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 991k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 991k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 870k, False: 121k] | | | | ------------------ | | ------------------ ------------------ 139| 870k| return luaV_flttointeger(fltvalue(obj), p, mode); ------------------ | | 332| 870k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 870k|#define check_exp(c,e) (e) | | ------------------ ------------------ 140| 121k| else if (ttisinteger(obj)) { ------------------ | | 328| 121k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 121k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 121k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 121k, False: 22] | | | | ------------------ | | ------------------ ------------------ 141| 121k| *p = ivalue(obj); ------------------ | | 333| 121k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 121k|#define check_exp(c,e) (e) | | ------------------ ------------------ 142| 121k| return 1; 143| 121k| } 144| 22| else 145| 22| return 0; 146| 991k|} luaV_tointeger: 152| 9|int luaV_tointeger (const TValue *obj, lua_Integer *p, F2Imod mode) { 153| 9| TValue v; 154| 9| if (l_strton(obj, &v)) /* does 'obj' point to a numerical string? */ ------------------ | Branch (154:7): [True: 0, False: 9] ------------------ 155| 0| obj = &v; /* change it to point to its corresponding number */ 156| 9| return luaV_tointegerns(obj, p, mode); 157| 9|} luaV_finishget: 288| 441k| const TValue *slot) { 289| 441k| int loop; /* counter to avoid infinite loops */ 290| 441k| const TValue *tm; /* metamethod */ 291| 441k| for (loop = 0; loop < MAXTAGLOOP; loop++) { ------------------ | | 49| 441k|#define MAXTAGLOOP 2000 ------------------ | Branch (291:18): [True: 441k, False: 0] ------------------ 292| 441k| if (slot == NULL) { /* 't' is not a table? */ ------------------ | Branch (292:9): [True: 0, False: 441k] ------------------ 293| 0| lua_assert(!ttistable(t)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 294| 0| tm = luaT_gettmbyobj(L, t, TM_INDEX); 295| 0| if (l_unlikely(notm(tm))) ------------------ | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 296| 0| luaG_typeerror(L, t, "index"); /* no metamethod */ 297| | /* else will try the metamethod */ 298| 0| } 299| 441k| else { /* 't' is a table */ 300| 441k| lua_assert(isempty(slot)); ------------------ | | 114| 441k|#define lua_assert(c) ((void)0) ------------------ 301| 441k| tm = fasttm(L, hvalue(t)->metatable, TM_INDEX); /* table's metamethod */ ------------------ | | 68| 441k|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 65| 441k|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (65:26): [True: 441k, False: 0] | | | | ------------------ | | | | 66| 441k| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (66:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 302| 441k| if (tm == NULL) { /* no metamethod? */ ------------------ | Branch (302:11): [True: 441k, False: 0] ------------------ 303| 441k| setnilvalue(s2v(val)); /* result is nil */ ------------------ | | 200| 441k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 441k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 304| 441k| return; 305| 441k| } 306| | /* else will try the metamethod */ 307| 441k| } 308| 0| if (ttisfunction(tm)) { /* is metamethod a function? */ ------------------ | | 594| 0|#define ttisfunction(o) checktype(o, LUA_TFUNCTION) | | ------------------ | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 309| 0| luaT_callTMres(L, tm, t, key, val); /* call it */ 310| 0| return; 311| 0| } 312| 0| t = tm; /* else try to access 'tm[key]' */ 313| 0| if (luaV_fastget(L, t, key, slot, luaH_get)) { /* fast track? */ ------------------ | | 86| 0| (!ttistable(t) \ | | ------------------ | | | | 682| 0|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 0] | | | Branch (86:4): [True: 0, False: 0] | | ------------------ | | 87| 0| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 0| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 684| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 0| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 0|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 314| 0| setobj2s(L, val, slot); /* done */ ------------------ | | 131| 0|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 315| 0| return; 316| 0| } 317| | /* else repeat (tail call 'luaV_finishget') */ 318| 0| } 319| 0| luaG_runerror(L, "'__index' chain too long; possible loop"); 320| 441k|} luaV_finishset: 331| 622k| TValue *val, const TValue *slot) { 332| 622k| int loop; /* counter to avoid infinite loops */ 333| 622k| for (loop = 0; loop < MAXTAGLOOP; loop++) { ------------------ | | 49| 622k|#define MAXTAGLOOP 2000 ------------------ | Branch (333:18): [True: 622k, False: 0] ------------------ 334| 622k| const TValue *tm; /* '__newindex' metamethod */ 335| 622k| if (slot != NULL) { /* is 't' a table? */ ------------------ | Branch (335:9): [True: 622k, False: 2] ------------------ 336| 622k| Table *h = hvalue(t); /* save 't' table */ ------------------ | | 684| 622k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 622k|#define check_exp(c,e) (e) | | ------------------ ------------------ 337| 622k| lua_assert(isempty(slot)); /* slot must be empty */ ------------------ | | 114| 622k|#define lua_assert(c) ((void)0) ------------------ 338| 622k| tm = fasttm(L, h->metatable, TM_NEWINDEX); /* get metamethod */ ------------------ | | 68| 622k|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 65| 622k|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (65:26): [True: 622k, False: 0] | | | | ------------------ | | | | 66| 622k| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (66:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 339| 622k| if (tm == NULL) { /* no metamethod? */ ------------------ | Branch (339:11): [True: 622k, False: 0] ------------------ 340| 622k| luaH_finishset(L, h, key, slot, val); /* set new value */ 341| 622k| invalidateTMcache(h); ------------------ | | 23| 622k|#define invalidateTMcache(t) ((t)->flags &= ~maskflags) | | ------------------ | | | | 55| 622k|#define maskflags (~(~0u << (TM_EQ + 1))) | | ------------------ ------------------ 342| 622k| luaC_barrierback(L, obj2gco(h), val); ------------------ | | 185| 622k|#define luaC_barrierback(L,p,v) ( \ | | 186| 622k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 622k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 622k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 622k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 18.4k, False: 604k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 182| 18.4k|#define luaC_objbarrierback(L,p,o) ( \ | | | | 183| 18.4k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 88| 18.4k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 18.4k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 36.8k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 1, False: 18.4k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 87| 1|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 1|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 1, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 138| 18.4k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 18.4k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 604k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 604k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 343| 622k| return; 344| 622k| } 345| | /* else will try the metamethod */ 346| 622k| } 347| 2| else { /* not a table; check metamethod */ 348| 2| tm = luaT_gettmbyobj(L, t, TM_NEWINDEX); 349| 2| if (l_unlikely(notm(tm))) ------------------ | | 688| 2|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 2|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 2, False: 0] | | | | ------------------ | | ------------------ ------------------ 350| 2| luaG_typeerror(L, t, "index"); 351| 2| } 352| | /* try the metamethod */ 353| 0| if (ttisfunction(tm)) { ------------------ | | 594| 0|#define ttisfunction(o) checktype(o, LUA_TFUNCTION) | | ------------------ | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 354| 0| luaT_callTM(L, tm, t, key, val); 355| 0| return; 356| 0| } 357| 0| t = tm; /* else repeat assignment over 'tm' */ 358| 0| if (luaV_fastget(L, t, key, slot, luaH_get)) { ------------------ | | 86| 0| (!ttistable(t) \ | | ------------------ | | | | 682| 0|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 0] | | | Branch (86:4): [True: 0, False: 0] | | ------------------ | | 87| 0| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 0| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 684| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 0| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 0|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 359| 0| luaV_finishfastset(L, t, slot, val); ------------------ | | 109| 0| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 0|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | | | ------------------ | | | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 0| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 0|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 0| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 0|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 0| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 360| 0| return; /* done */ 361| 0| } 362| | /* else 'return luaV_finishset(L, t, key, val, slot)' (loop) */ 363| 0| } 364| 0| luaG_runerror(L, "'__newindex' chain too long; possible loop"); 365| 622k|} luaV_equalobj: 565| 7.36M|int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) { 566| 7.36M| const TValue *tm; 567| 7.36M| if (ttypetag(t1) != ttypetag(t2)) { /* not the same variant? */ ------------------ | | 84| 7.36M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 7.36M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ if (ttypetag(t1) != ttypetag(t2)) { /* not the same variant? */ ------------------ | | 84| 7.36M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 7.36M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ | Branch (567:7): [True: 94.5k, False: 7.27M] ------------------ 568| 94.5k| if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 87| 94.5k|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 94.5k|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 87| 189k|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 94.5k|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 87| 76.1k|#define ttype(o) (novariant(rawtt(o))) | | ------------------ | | | | 80| 76.1k|#define novariant(t) ((t) & 0x0F) | | ------------------ ------------------ if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER) ------------------ | | 68| 76.1k|#define LUA_TNUMBER 3 ------------------ | Branch (568:9): [True: 18.3k, False: 76.1k] | Branch (568:35): [True: 11.7k, False: 64.3k] ------------------ 569| 30.1k| return 0; /* only numbers can be equal with different variants */ 570| 64.3k| else { /* two numbers with different variants */ 571| | /* One of them is an integer. If the other does not have an 572| | integer value, they cannot be equal; otherwise, compare their 573| | integer values. */ 574| 64.3k| lua_Integer i1, i2; 575| 64.3k| return (luaV_tointegerns(t1, &i1, F2Ieq) && ------------------ | Branch (575:15): [True: 64.3k, False: 0] ------------------ 576| 64.3k| luaV_tointegerns(t2, &i2, F2Ieq) && ------------------ | Branch (576:15): [True: 55.1k, False: 9.19k] ------------------ 577| 64.3k| i1 == i2); ------------------ | Branch (577:15): [True: 0, False: 55.1k] ------------------ 578| 64.3k| } 579| 94.5k| } 580| | /* values have same type and same variant */ 581| 7.27M| switch (ttypetag(t1)) { ------------------ | | 84| 7.27M|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 7.27M|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 582| 546| case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1; ------------------ | | 183| 391|#define LUA_VNIL makevariant(LUA_TNIL, 0) | | ------------------ | | | | 42| 391|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1; ------------------ | | 239| 391|#define LUA_VFALSE makevariant(LUA_TBOOLEAN, 0) | | ------------------ | | | | 42| 391|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNIL: case LUA_VFALSE: case LUA_VTRUE: return 1; ------------------ | | 240| 546|#define LUA_VTRUE makevariant(LUA_TBOOLEAN, 1) | | ------------------ | | | | 42| 546|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (582:5): [True: 391, False: 7.27M] | Branch (582:20): [True: 0, False: 7.27M] | Branch (582:37): [True: 155, False: 7.27M] ------------------ 583| 41.2k| case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2)); ------------------ | | 323| 41.2k|#define LUA_VNUMINT makevariant(LUA_TNUMBER, 0) /* integer numbers */ | | ------------------ | | | | 42| 41.2k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2)); ------------------ | | 333| 41.2k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 41.2k|#define check_exp(c,e) (e) | | ------------------ ------------------ case LUA_VNUMINT: return (ivalue(t1) == ivalue(t2)); ------------------ | | 333| 41.2k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 41.2k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (583:5): [True: 41.2k, False: 7.23M] ------------------ 584| 40.8k| case LUA_VNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2)); ------------------ | | 324| 40.8k|#define LUA_VNUMFLT makevariant(LUA_TNUMBER, 1) /* float numbers */ | | ------------------ | | | | 42| 40.8k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2)); ------------------ | | 350| 40.8k|#define luai_numeq(a,b) ((a)==(b)) ------------------ | Branch (584:5): [True: 40.8k, False: 7.23M] ------------------ 585| 0| case LUA_VLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); ------------------ | | 429| 0|#define LUA_VLIGHTUSERDATA makevariant(LUA_TLIGHTUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); ------------------ | | 436| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ case LUA_VLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); ------------------ | | 436| 0|#define pvalue(o) check_exp(ttislightuserdata(o), val_(o).p) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (585:5): [True: 0, False: 7.27M] ------------------ 586| 0| case LUA_VLCF: return fvalue(t1) == fvalue(t2); ------------------ | | 591| 0|#define LUA_VLCF makevariant(LUA_TFUNCTION, 1) /* light C function */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLCF: return fvalue(t1) == fvalue(t2); ------------------ | | 605| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ case LUA_VLCF: return fvalue(t1) == fvalue(t2); ------------------ | | 605| 0|#define fvalue(o) check_exp(ttislcf(o), val_(o).f) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (586:5): [True: 0, False: 7.27M] ------------------ 587| 7.18M| case LUA_VSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 360| 7.18M|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 7.18M|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 41| 7.18M|#define eqshrstr(a,b) check_exp((a)->tt == LUA_VSHRSTR, (a) == (b)) | | ------------------ | | | | 115| 7.18M|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (587:5): [True: 7.18M, False: 92.8k] ------------------ 588| 10.2k| case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 361| 10.2k|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 10.2k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 369| 10.2k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 10.2k|#define check_exp(c,e) (e) | | ------------------ ------------------ case LUA_VLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); ------------------ | | 369| 10.2k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 10.2k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (588:5): [True: 10.2k, False: 7.26M] ------------------ 589| 0| case LUA_VUSERDATA: { ------------------ | | 431| 0|#define LUA_VUSERDATA makevariant(LUA_TUSERDATA, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (589:5): [True: 0, False: 7.27M] ------------------ 590| 0| if (uvalue(t1) == uvalue(t2)) return 1; ------------------ | | 437| 0|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ if (uvalue(t1) == uvalue(t2)) return 1; ------------------ | | 437| 0|#define uvalue(o) check_exp(ttisfulluserdata(o), gco2u(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (590:11): [True: 0, False: 0] ------------------ 591| 0| else if (L == NULL) return 0; ------------------ | Branch (591:16): [True: 0, False: 0] ------------------ 592| 0| tm = fasttm(L, uvalue(t1)->metatable, TM_EQ); ------------------ | | 68| 0|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 65| 0|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (65:26): [True: 0, False: 0] | | | | ------------------ | | | | 66| 0| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (66:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 593| 0| if (tm == NULL) ------------------ | Branch (593:11): [True: 0, False: 0] ------------------ 594| 0| tm = fasttm(L, uvalue(t2)->metatable, TM_EQ); ------------------ | | 68| 0|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 65| 0|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (65:26): [True: 0, False: 0] | | | | ------------------ | | | | 66| 0| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (66:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 595| 0| break; /* will try TM */ 596| 0| } 597| 0| case LUA_VTABLE: { ------------------ | | 680| 0|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (597:5): [True: 0, False: 7.27M] ------------------ 598| 0| if (hvalue(t1) == hvalue(t2)) return 1; ------------------ | | 684| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ if (hvalue(t1) == hvalue(t2)) return 1; ------------------ | | 684| 0|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (598:11): [True: 0, False: 0] ------------------ 599| 0| else if (L == NULL) return 0; ------------------ | Branch (599:16): [True: 0, False: 0] ------------------ 600| 0| tm = fasttm(L, hvalue(t1)->metatable, TM_EQ); ------------------ | | 68| 0|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 65| 0|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (65:26): [True: 0, False: 0] | | | | ------------------ | | | | 66| 0| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (66:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 601| 0| if (tm == NULL) ------------------ | Branch (601:11): [True: 0, False: 0] ------------------ 602| 0| tm = fasttm(L, hvalue(t2)->metatable, TM_EQ); ------------------ | | 68| 0|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 65| 0|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (65:26): [True: 0, False: 0] | | | | ------------------ | | | | 66| 0| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (66:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 603| 0| break; /* will try TM */ 604| 0| } 605| 0| default: ------------------ | Branch (605:5): [True: 0, False: 7.27M] ------------------ 606| 0| return gcvalue(t1) == gcvalue(t2); ------------------ | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ return gcvalue(t1) == gcvalue(t2); ------------------ | | 305| 0|#define gcvalue(o) check_exp(iscollectable(o), val_(o).gc) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 607| 7.27M| } 608| 0| if (tm == NULL) /* no TM? */ ------------------ | Branch (608:7): [True: 0, False: 0] ------------------ 609| 0| return 0; /* objects are different */ 610| 0| else { 611| 0| luaT_callTMres(L, tm, t1, t2, L->top.p); /* call TM */ 612| 0| return !l_isfalse(s2v(L->top.p)); ------------------ | | 247| 0|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 0|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 613| 0| } 614| 0|} luaV_concat: 638| 83.4k|void luaV_concat (lua_State *L, int total) { 639| 83.4k| if (total == 1) ------------------ | Branch (639:7): [True: 0, False: 83.4k] ------------------ 640| 0| return; /* "all" values already concatenated */ 641| 83.4k| do { 642| 83.4k| StkId top = L->top.p; 643| 83.4k| int n = 2; /* number of elements handled in this pass (at least 2) */ 644| 83.4k| if (!(ttisstring(s2v(top - 2)) || cvt2str(s2v(top - 2))) || ------------------ | | 363| 83.4k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 166k|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 83.4k|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 83.4k|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 656, False: 82.7k] | | | | ------------------ | | ------------------ ------------------ if (!(ttisstring(s2v(top - 2)) || cvt2str(s2v(top - 2))) || ------------------ | | 17| 83.4k|#define cvt2str(o) ttisnumber(o) | | ------------------ | | | | 326| 82.7k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 82.7k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 82.7k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 82.7k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 82.7k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 645| 83.4k| !tostring(L, s2v(top - 1))) ------------------ | | 619| 83.4k| (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 363| 83.4k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | | | ------------------ | | | | | | 92| 166k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 83.4k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 83.4k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 18.5k, False: 64.9k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 17| 64.9k|#define cvt2str(o) ttisnumber(o) | | | | ------------------ | | | | | | 326| 64.9k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | | | ------------------ | | | | | | | | 92| 129k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 64.9k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 64.9k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (92:25): [True: 64.9k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (619:35): [True: 64.9k, False: 0] | | ------------------ ------------------ 646| 0| luaT_tryconcatTM(L); /* may invalidate 'top' */ 647| 83.4k| else if (isemptystr(s2v(top - 1))) /* second operand is empty? */ ------------------ | | 621| 83.4k|#define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 364| 83.4k|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | | | ------------------ | | | | | | 91| 166k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 83.4k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 83.3k, False: 75] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 369| 83.3k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | | | ------------------ | | | | | | 115| 83.3k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (621:44): [True: 34, False: 83.3k] | | ------------------ ------------------ 648| 83.4k| cast_void(tostring(L, s2v(top - 2))); /* result is first operand */ ------------------ | | 138| 34|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 34|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | | | | Branch (136:27): [True: 0, False: 0] | | | | | Branch (136:27): [True: 0, False: 0] | | | | | Branch (136:27): [True: 34, False: 0] | | | | ------------------ | | ------------------ ------------------ 649| 83.4k| else if (isemptystr(s2v(top - 2))) { /* first operand is empty string? */ ------------------ | | 621| 83.4k|#define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 364| 83.4k|#define ttisshrstring(o) checktag((o), ctb(LUA_VSHRSTR)) | | | | ------------------ | | | | | | 91| 166k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 83.4k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 38, False: 83.3k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0) | | ------------------ | | | | 369| 38|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | | | ------------------ | | | | | | 115| 38|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (621:44): [True: 0, False: 38] | | ------------------ ------------------ 650| 0| setobjs2s(L, top - 2, top - 1); /* result is second op. */ ------------------ | | 129| 0|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 651| 0| } 652| 83.4k| else { 653| | /* at least two non-empty string values; get as many as possible */ 654| 83.4k| size_t tl = vslen(s2v(top - 1)); ------------------ | | 413| 83.4k|#define vslen(o) tsslen(tsvalue(o)) | | ------------------ | | | | 410| 83.4k|#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen) | | | | ------------------ | | | | | | 360| 83.4k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | | | ------------------ | | | | | | | | 42| 83.4k|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (410:20): [True: 83.3k, False: 75] | | | | ------------------ | | ------------------ ------------------ 655| 83.4k| TString *ts; 656| | /* collect total length and number of strings */ 657| 166k| for (n = 1; n < total && tostring(L, s2v(top - n - 1)); n++) { ------------------ | | 619| 83.4k| (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 363| 83.4k|#define ttisstring(o) checktype((o), LUA_TSTRING) | | | | ------------------ | | | | | | 92| 166k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 83.4k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 83.4k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 622, False: 82.7k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) | | ------------------ | | | | 17| 82.7k|#define cvt2str(o) ttisnumber(o) | | | | ------------------ | | | | | | 326| 82.7k|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | | | ------------------ | | | | | | | | 92| 165k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 82.7k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 82.7k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (92:25): [True: 82.7k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (619:35): [True: 82.7k, False: 0] | | ------------------ ------------------ | Branch (657:19): [True: 83.4k, False: 83.4k] ------------------ 658| 83.4k| size_t l = vslen(s2v(top - n - 1)); ------------------ | | 413| 83.4k|#define vslen(o) tsslen(tsvalue(o)) | | ------------------ | | | | 410| 83.4k|#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen) | | | | ------------------ | | | | | | 360| 83.4k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | | | ------------------ | | | | | | | | 42| 83.4k|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (410:20): [True: 82.8k, False: 584] | | | | ------------------ | | ------------------ ------------------ 659| 83.4k| if (l_unlikely(l >= (MAX_SIZE/sizeof(char)) - tl)) { ------------------ | | 688| 83.4k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 166k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 83.4k] | | | | | Branch (676:46): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 660| 0| L->top.p = top - total; /* pop strings to avoid wasting stack */ 661| 0| luaG_runerror(L, "string length overflow"); 662| 0| } 663| 83.4k| tl += l; 664| 83.4k| } 665| 83.4k| if (tl <= LUAI_MAXSHORTLEN) { /* is result a short string? */ ------------------ | | 216| 83.4k|#define LUAI_MAXSHORTLEN 40 ------------------ | Branch (665:11): [True: 82.7k, False: 638] ------------------ 666| 82.7k| char buff[LUAI_MAXSHORTLEN]; 667| 82.7k| copy2buff(top, n, buff); /* copy strings to buffer */ 668| 82.7k| ts = luaS_newlstr(L, buff, tl); 669| 82.7k| } 670| 638| else { /* long string; copy strings directly to final result */ 671| 638| ts = luaS_createlngstrobj(L, tl); 672| 638| copy2buff(top, n, getstr(ts)); ------------------ | | 403| 638|#define getstr(ts) ((ts)->contents) ------------------ 673| 638| } 674| 83.4k| setsvalue2s(L, top - n, ts); /* create result */ ------------------ | | 377| 83.4k|#define setsvalue2s(L,o,s) setsvalue(L,s2v(o),s) | | ------------------ | | | | 372| 83.4k| { TValue *io = (obj); TString *x_ = (x); \ | | | | 373| 83.4k| val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 72| 83.4k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 390| 83.4k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 83.4k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \ | | | | ------------------ | | | | | | 114| 83.4k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 374| 83.4k| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 83.4k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 83.4k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 83.4k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 675| 83.4k| } 676| 83.4k| total -= n - 1; /* got 'n' strings to create one new */ 677| 83.4k| L->top.p -= n - 1; /* popped 'n' strings and pushed one */ 678| 83.4k| } while (total > 1); /* repeat until only 1 result left */ ------------------ | Branch (678:12): [True: 0, False: 83.4k] ------------------ 679| 83.4k|} luaV_objlen: 685| 506k|void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) { 686| 506k| const TValue *tm; 687| 506k| switch (ttypetag(rb)) { ------------------ | | 84| 506k|#define ttypetag(o) withvariant(rawtt(o)) | | ------------------ | | | | 83| 506k|#define withvariant(t) ((t) & 0x3F) | | ------------------ ------------------ 688| 506k| case LUA_VTABLE: { ------------------ | | 680| 506k|#define LUA_VTABLE makevariant(LUA_TTABLE, 0) | | ------------------ | | | | 42| 506k|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (688:5): [True: 506k, False: 2] ------------------ 689| 506k| Table *h = hvalue(rb); ------------------ | | 684| 506k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 506k|#define check_exp(c,e) (e) | | ------------------ ------------------ 690| 506k| tm = fasttm(L, h->metatable, TM_LEN); ------------------ | | 68| 506k|#define fasttm(l,et,e) gfasttm(G(l), et, e) | | ------------------ | | | | 65| 506k|#define gfasttm(g,et,e) ((et) == NULL ? NULL : \ | | | | ------------------ | | | | | Branch (65:26): [True: 506k, False: 0] | | | | ------------------ | | | | 66| 506k| ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e])) | | | | ------------------ | | | | | Branch (66:3): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 691| 506k| if (tm) break; /* metamethod? break switch to call it */ ------------------ | Branch (691:11): [True: 0, False: 506k] ------------------ 692| 506k| setivalue(s2v(ra), luaH_getn(h)); /* else primitive len */ ------------------ | | 345| 506k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 506k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 506k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 693| 506k| return; 694| 506k| } 695| 2| case LUA_VSHRSTR: { ------------------ | | 360| 2|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | ------------------ | | | | 42| 2|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (695:5): [True: 2, False: 506k] ------------------ 696| 2| setivalue(s2v(ra), tsvalue(rb)->shrlen); ------------------ | | 345| 2| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 2|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 2|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 697| 2| return; 698| 506k| } 699| 0| case LUA_VLNGSTR: { ------------------ | | 361| 0|#define LUA_VLNGSTR makevariant(LUA_TSTRING, 1) /* long strings */ | | ------------------ | | | | 42| 0|#define makevariant(t,v) ((t) | ((v) << 4)) | | ------------------ ------------------ | Branch (699:5): [True: 0, False: 506k] ------------------ 700| 0| setivalue(s2v(ra), tsvalue(rb)->u.lnglen); ------------------ | | 345| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 0|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 701| 0| return; 702| 506k| } 703| 0| default: { /* try metamethod */ ------------------ | Branch (703:5): [True: 0, False: 506k] ------------------ 704| 0| tm = luaT_gettmbyobj(L, rb, TM_LEN); 705| 0| if (l_unlikely(notm(tm))) /* no metamethod? */ ------------------ | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 706| 0| luaG_typeerror(L, rb, "get length of"); 707| 0| break; 708| 0| } 709| 506k| } 710| 0| luaT_callTMres(L, tm, rb, rb, ra); 711| 0|} luaV_idiv: 720| 211k|lua_Integer luaV_idiv (lua_State *L, lua_Integer m, lua_Integer n) { 721| 211k| if (l_unlikely(l_castS2U(n) + 1u <= 1u)) { /* special cases: -1 or 0 */ ------------------ | | 688| 211k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 211k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 211k] | | | | ------------------ | | ------------------ ------------------ 722| 0| if (n == 0) ------------------ | Branch (722:9): [True: 0, False: 0] ------------------ 723| 0| luaG_runerror(L, "attempt to divide by zero"); 724| 0| return intop(-, 0, m); /* n==-1; avoid overflow with 0x80000...//-1 */ ------------------ | | 73| 0|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 0|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 725| 0| } 726| 211k| else { 727| 211k| lua_Integer q = m / n; /* perform C division */ 728| 211k| if ((m ^ n) < 0 && m % n != 0) /* 'm/n' would be negative non-integer? */ ------------------ | Branch (728:9): [True: 183k, False: 27.6k] | Branch (728:24): [True: 183k, False: 22] ------------------ 729| 183k| q -= 1; /* correct result for different rounding */ 730| 211k| return q; 731| 211k| } 732| 211k|} luaV_mod: 740| 114k|lua_Integer luaV_mod (lua_State *L, lua_Integer m, lua_Integer n) { 741| 114k| if (l_unlikely(l_castS2U(n) + 1u <= 1u)) { /* special cases: -1 or 0 */ ------------------ | | 688| 114k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 114k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 164, False: 114k] | | | | ------------------ | | ------------------ ------------------ 742| 164| if (n == 0) ------------------ | Branch (742:9): [True: 0, False: 164] ------------------ 743| 0| luaG_runerror(L, "attempt to perform 'n%%0'"); 744| 164| return 0; /* m % -1 == 0; avoid overflow with 0x80000...%-1 */ 745| 164| } 746| 114k| else { 747| 114k| lua_Integer r = m % n; 748| 114k| if (r != 0 && (r ^ n) < 0) /* 'm/n' would be non-integer negative? */ ------------------ | Branch (748:9): [True: 85.0k, False: 29.4k] | Branch (748:19): [True: 82.8k, False: 2.19k] ------------------ 749| 82.8k| r += n; /* correct result for different rounding */ 750| 114k| return r; 751| 114k| } 752| 114k|} luaV_modf: 758| 47.5k|lua_Number luaV_modf (lua_State *L, lua_Number m, lua_Number n) { 759| 47.5k| lua_Number r; 760| 47.5k| luai_nummod(L, m, n, r); ------------------ | | 334| 47.5k| { (void)L; (m) = l_mathop(fmod)(a,b); \ | | ------------------ | | | | 473| 47.5k|#define l_mathop(op) op | | ------------------ | | 335| 47.5k| if (((m) > 0) ? (b) < 0 : ((m) < 0 && (b) > 0)) (m) += (b); } | | ------------------ | | | Branch (335:9): [True: 46.4k, False: 1.04k] | | | Branch (335:9): [True: 669, False: 46.8k] | | | Branch (335:32): [True: 669, False: 371] | | | Branch (335:43): [True: 669, False: 0] | | ------------------ ------------------ 761| 47.5k| return r; 762| 47.5k|} luaV_shiftl: 772| 193k|lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) { 773| 193k| if (y < 0) { /* shift right? */ ------------------ | Branch (773:7): [True: 37.3k, False: 156k] ------------------ 774| 37.3k| if (y <= -NBITS) return 0; ------------------ | | 766| 37.3k|#define NBITS cast_int(sizeof(lua_Integer) * CHAR_BIT) | | ------------------ | | | | 141| 37.3k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 37.3k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (774:9): [True: 37.2k, False: 90] ------------------ 775| 90| else return intop(>>, x, -y); ------------------ | | 73| 90|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 90|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 776| 37.3k| } 777| 156k| else { /* shift left */ 778| 156k| if (y >= NBITS) return 0; ------------------ | | 766| 156k|#define NBITS cast_int(sizeof(lua_Integer) * CHAR_BIT) | | ------------------ | | | | 141| 156k|#define cast_int(i) cast(int, (i)) | | | | ------------------ | | | | | | 136| 156k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ | Branch (778:9): [True: 47.3k, False: 109k] ------------------ 779| 109k| else return intop(<<, x, y); ------------------ | | 73| 109k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 109k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 780| 156k| } 781| 193k|} luaV_execute: 1146| 40|void luaV_execute (lua_State *L, CallInfo *ci) { 1147| 40| LClosure *cl; 1148| 40| TValue *k; 1149| 40| StkId base; 1150| 40| const Instruction *pc; 1151| 40| int trap; 1152| 40|#if LUA_USE_JUMPTABLE 1153| 40|#include "ljumptab.h" ------------------ | | 1| |/* | | 2| |** $Id: ljumptab.h $ | | 3| |** Jump Table for the Lua interpreter | | 4| |** See Copyright Notice in lua.h | | 5| |*/ | | 6| | | | 7| | | | 8| 40|#undef vmdispatch | | 9| 40|#undef vmcase | | 10| 40|#undef vmbreak | | 11| | | | 12| 40|#define vmdispatch(x) goto *disptab[x]; | | 13| | | | 14| 40|#define vmcase(l) L_##l: | | 15| | | | 16| 40|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | 17| | | | 18| | | | 19| 40|static const void *const disptab[NUM_OPCODES] = { | | 20| | | | 21| |#if 0 | | 22| |** you can update the following list with this command: | | 23| |** | | 24| |** sed -n '/^OP_/\!d; s/OP_/\&\&L_OP_/ ; s/,.*/,/ ; s/\/.*// ; p' lopcodes.h | | 25| |** | | 26| |#endif | | 27| | | | 28| 40|&&L_OP_MOVE, | | 29| 40|&&L_OP_LOADI, | | 30| 40|&&L_OP_LOADF, | | 31| 40|&&L_OP_LOADK, | | 32| 40|&&L_OP_LOADKX, | | 33| 40|&&L_OP_LOADFALSE, | | 34| 40|&&L_OP_LFALSESKIP, | | 35| 40|&&L_OP_LOADTRUE, | | 36| 40|&&L_OP_LOADNIL, | | 37| 40|&&L_OP_GETUPVAL, | | 38| 40|&&L_OP_SETUPVAL, | | 39| 40|&&L_OP_GETTABUP, | | 40| 40|&&L_OP_GETTABLE, | | 41| 40|&&L_OP_GETI, | | 42| 40|&&L_OP_GETFIELD, | | 43| 40|&&L_OP_SETTABUP, | | 44| 40|&&L_OP_SETTABLE, | | 45| 40|&&L_OP_SETI, | | 46| 40|&&L_OP_SETFIELD, | | 47| 40|&&L_OP_NEWTABLE, | | 48| 40|&&L_OP_SELF, | | 49| 40|&&L_OP_ADDI, | | 50| 40|&&L_OP_ADDK, | | 51| 40|&&L_OP_SUBK, | | 52| 40|&&L_OP_MULK, | | 53| 40|&&L_OP_MODK, | | 54| 40|&&L_OP_POWK, | | 55| 40|&&L_OP_DIVK, | | 56| 40|&&L_OP_IDIVK, | | 57| 40|&&L_OP_BANDK, | | 58| 40|&&L_OP_BORK, | | 59| 40|&&L_OP_BXORK, | | 60| 40|&&L_OP_SHRI, | | 61| 40|&&L_OP_SHLI, | | 62| 40|&&L_OP_ADD, | | 63| 40|&&L_OP_SUB, | | 64| 40|&&L_OP_MUL, | | 65| 40|&&L_OP_MOD, | | 66| 40|&&L_OP_POW, | | 67| 40|&&L_OP_DIV, | | 68| 40|&&L_OP_IDIV, | | 69| 40|&&L_OP_BAND, | | 70| 40|&&L_OP_BOR, | | 71| 40|&&L_OP_BXOR, | | 72| 40|&&L_OP_SHL, | | 73| 40|&&L_OP_SHR, | | 74| 40|&&L_OP_MMBIN, | | 75| 40|&&L_OP_MMBINI, | | 76| 40|&&L_OP_MMBINK, | | 77| 40|&&L_OP_UNM, | | 78| 40|&&L_OP_BNOT, | | 79| 40|&&L_OP_NOT, | | 80| 40|&&L_OP_LEN, | | 81| 40|&&L_OP_CONCAT, | | 82| 40|&&L_OP_CLOSE, | | 83| 40|&&L_OP_TBC, | | 84| 40|&&L_OP_JMP, | | 85| 40|&&L_OP_EQ, | | 86| 40|&&L_OP_LT, | | 87| 40|&&L_OP_LE, | | 88| 40|&&L_OP_EQK, | | 89| 40|&&L_OP_EQI, | | 90| 40|&&L_OP_LTI, | | 91| 40|&&L_OP_LEI, | | 92| 40|&&L_OP_GTI, | | 93| 40|&&L_OP_GEI, | | 94| 40|&&L_OP_TEST, | | 95| 40|&&L_OP_TESTSET, | | 96| 40|&&L_OP_CALL, | | 97| 40|&&L_OP_TAILCALL, | | 98| 40|&&L_OP_RETURN, | | 99| 40|&&L_OP_RETURN0, | | 100| 40|&&L_OP_RETURN1, | | 101| 40|&&L_OP_FORLOOP, | | 102| 40|&&L_OP_FORPREP, | | 103| 40|&&L_OP_TFORPREP, | | 104| 40|&&L_OP_TFORCALL, | | 105| 40|&&L_OP_TFORLOOP, | | 106| 40|&&L_OP_SETLIST, | | 107| 40|&&L_OP_CLOSURE, | | 108| 40|&&L_OP_VARARG, | | 109| 40|&&L_OP_VARARGPREP, | | 110| 40|&&L_OP_EXTRAARG | | 111| | | | 112| 40|}; ------------------ 1154| 40|#endif 1155| 19.7k| startfunc: 1156| 19.7k| trap = L->hookmask; 1157| 38.1k| returning: /* trap already set */ 1158| 38.1k| cl = clLvalue(s2v(ci->func.p)); ------------------ | | 604| 38.1k|#define clLvalue(o) check_exp(ttisLclosure(o), gco2lcl(val_(o).gc)) | | ------------------ | | | | 115| 38.1k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1159| 38.1k| k = cl->p->k; 1160| 38.1k| pc = ci->u.l.savedpc; 1161| 38.1k| if (l_unlikely(trap)) { ------------------ | | 688| 38.1k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 38.1k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 38.1k] | | | | ------------------ | | ------------------ ------------------ 1162| 0| if (pc == cl->p->code) { /* first instruction (not resuming)? */ ------------------ | Branch (1162:9): [True: 0, False: 0] ------------------ 1163| 0| if (cl->p->is_vararg) ------------------ | Branch (1163:11): [True: 0, False: 0] ------------------ 1164| 0| trap = 0; /* hooks will start after VARARGPREP instruction */ 1165| 0| else /* check 'call' hook */ 1166| 0| luaD_hookcall(L, ci); 1167| 0| } 1168| 0| ci->u.l.trap = 1; /* assume trap is on, for now */ 1169| 0| } 1170| 38.1k| base = ci->func.p + 1; 1171| | /* main loop of interpreter */ 1172| 38.1k| for (;;) { 1173| 38.1k| Instruction i; /* instruction being executed */ 1174| 38.1k| vmfetch(); ------------------ | | 1133| 38.1k|#define vmfetch() { \ | | 1134| 38.1k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | ------------------ | | | | 688| 38.1k|#define l_unlikely(x) luai_unlikely(x) | | | | ------------------ | | | | | | 676| 38.1k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | ------------------ | | | | | | | Branch (676:26): [True: 0, False: 38.1k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | 1136| 0| updatebase(ci); /* correct stack */ \ | | ------------------ | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | ------------------ | | 1137| 0| } \ | | 1138| 38.1k| i = *(pc++); \ | | 1139| 38.1k|} ------------------ 1175| | #if 0 1176| | /* low-level line tracing for debugging Lua */ 1177| | printf("line: %d\n", luaG_getfuncline(cl->p, pcRel(pc, cl->p))); 1178| | #endif 1179| 38.1k| lua_assert(base == ci->func.p + 1); ------------------ | | 114| 38.1k|#define lua_assert(c) ((void)0) ------------------ 1180| 38.1k| lua_assert(base <= L->top.p && L->top.p <= L->stack_last.p); ------------------ | | 114| 38.1k|#define lua_assert(c) ((void)0) ------------------ 1181| | /* invalidate top for instructions not expecting it */ 1182| 38.1k| lua_assert(isIT(i) || (cast_void(L->top.p = base), 1)); ------------------ | | 114| 38.1k|#define lua_assert(c) ((void)0) ------------------ 1183| 38.1k| vmdispatch (GET_OPCODE(i)) { ------------------ | | 12| 38.1k|#define vmdispatch(x) goto *disptab[x]; ------------------ 1184| 782k| vmcase(OP_MOVE) { ------------------ | | 14| 782k|#define vmcase(l) L_##l: ------------------ 1185| 782k| StkId ra = RA(i); ------------------ | | 1059| 782k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 782k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 782k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 782k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 782k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1186| 782k| setobjs2s(L, ra, RB(i)); ------------------ | | 129| 782k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 782k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 782k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 782k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 782k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 782k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 782k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 782k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 782k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1187| 782k| vmbreak; ------------------ | | 16| 782k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 782k|#define vmfetch() { \ | | | | 1134| 782k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 782k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 782k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 782k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 782k| i = *(pc++); \ | | | | 1139| 782k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 782k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1188| 782k| } 1189| 782k| vmcase(OP_LOADI) { ------------------ | | 14| 184k|#define vmcase(l) L_##l: ------------------ 1190| 184k| StkId ra = RA(i); ------------------ | | 1059| 184k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 184k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 184k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 184k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 184k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1191| 184k| lua_Integer b = GETARG_sBx(i); ------------------ | | 147| 184k| check_exp(checkopm(i, iAsBx), getarg(i, POS_Bx, SIZE_Bx) - OFFSET_sBx) | | ------------------ | | | | 115| 184k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1192| 184k| setivalue(s2v(ra), b); ------------------ | | 345| 184k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 184k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 184k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1193| 184k| vmbreak; ------------------ | | 16| 184k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 184k|#define vmfetch() { \ | | | | 1134| 184k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 184k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 184k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 184k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 184k| i = *(pc++); \ | | | | 1139| 184k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 184k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1194| 184k| } 1195| 241k| vmcase(OP_LOADF) { ------------------ | | 14| 241k|#define vmcase(l) L_##l: ------------------ 1196| 241k| StkId ra = RA(i); ------------------ | | 1059| 241k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 241k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 241k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 241k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 241k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1197| 241k| int b = GETARG_sBx(i); ------------------ | | 147| 241k| check_exp(checkopm(i, iAsBx), getarg(i, POS_Bx, SIZE_Bx) - OFFSET_sBx) | | ------------------ | | | | 115| 241k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1198| 241k| setfltvalue(s2v(ra), cast_num(b)); ------------------ | | 339| 241k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 241k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 241k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1199| 241k| vmbreak; ------------------ | | 16| 241k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 241k|#define vmfetch() { \ | | | | 1134| 241k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 241k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 241k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 241k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 241k| i = *(pc++); \ | | | | 1139| 241k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 241k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1200| 241k| } 1201| 279k| vmcase(OP_LOADK) { ------------------ | | 14| 279k|#define vmcase(l) L_##l: ------------------ 1202| 279k| StkId ra = RA(i); ------------------ | | 1059| 279k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 279k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 279k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 279k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 279k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1203| 279k| TValue *rb = k + GETARG_Bx(i); ------------------ | | 140| 279k|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 115| 279k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1204| 279k| setobj2s(L, ra, rb); ------------------ | | 131| 279k|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 279k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 279k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 279k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 279k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 279k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 279k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 279k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 279k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1205| 279k| vmbreak; ------------------ | | 16| 279k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 279k|#define vmfetch() { \ | | | | 1134| 279k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 279k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 279k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 279k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 279k| i = *(pc++); \ | | | | 1139| 279k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 279k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1206| 279k| } 1207| 279k| vmcase(OP_LOADKX) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1208| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1209| 0| TValue *rb; 1210| 0| rb = k + GETARG_Ax(*pc); pc++; ------------------ | | 143| 0|#define GETARG_Ax(i) check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1211| 0| setobj2s(L, ra, rb); ------------------ | | 131| 0|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1212| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1213| 0| } 1214| 11.7k| vmcase(OP_LOADFALSE) { ------------------ | | 14| 11.7k|#define vmcase(l) L_##l: ------------------ 1215| 11.7k| StkId ra = RA(i); ------------------ | | 1059| 11.7k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 11.7k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 11.7k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 11.7k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 11.7k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1216| 11.7k| setbfvalue(s2v(ra)); ------------------ | | 250| 11.7k|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 11.7k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1217| 11.7k| vmbreak; ------------------ | | 16| 11.7k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 11.7k|#define vmfetch() { \ | | | | 1134| 11.7k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 11.7k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 11.7k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 11.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 11.7k| i = *(pc++); \ | | | | 1139| 11.7k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 11.7k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1218| 11.7k| } 1219| 183k| vmcase(OP_LFALSESKIP) { ------------------ | | 14| 183k|#define vmcase(l) L_##l: ------------------ 1220| 183k| StkId ra = RA(i); ------------------ | | 1059| 183k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 183k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 183k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 183k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 183k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1221| 183k| setbfvalue(s2v(ra)); ------------------ | | 250| 183k|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 183k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1222| 183k| pc++; /* skip next instruction */ 1223| 183k| vmbreak; ------------------ | | 16| 183k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 183k|#define vmfetch() { \ | | | | 1134| 183k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 183k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 183k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 183k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 183k| i = *(pc++); \ | | | | 1139| 183k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 183k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1224| 183k| } 1225| 304k| vmcase(OP_LOADTRUE) { ------------------ | | 14| 304k|#define vmcase(l) L_##l: ------------------ 1226| 304k| StkId ra = RA(i); ------------------ | | 1059| 304k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 304k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 304k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 304k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 304k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1227| 304k| setbtvalue(s2v(ra)); ------------------ | | 251| 304k|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 304k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1228| 304k| vmbreak; ------------------ | | 16| 304k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 304k|#define vmfetch() { \ | | | | 1134| 304k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 304k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 304k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 304k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 304k| i = *(pc++); \ | | | | 1139| 304k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 304k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1229| 304k| } 1230| 304k| vmcase(OP_LOADNIL) { ------------------ | | 14| 44.6k|#define vmcase(l) L_##l: ------------------ 1231| 44.6k| StkId ra = RA(i); ------------------ | | 1059| 44.6k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 44.6k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 44.6k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 44.6k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 44.6k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1232| 44.6k| int b = GETARG_B(i); ------------------ | | 128| 44.6k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 44.6k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1233| 299k| do { 1234| 299k| setnilvalue(s2v(ra++)); ------------------ | | 200| 299k|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 299k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1235| 299k| } while (b--); ------------------ | Branch (1235:18): [True: 254k, False: 44.6k] ------------------ 1236| 44.6k| vmbreak; ------------------ | | 16| 44.6k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 44.6k|#define vmfetch() { \ | | | | 1134| 44.6k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 44.6k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 44.6k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 44.6k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 44.6k| i = *(pc++); \ | | | | 1139| 44.6k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 44.6k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1237| 44.6k| } 1238| 2.40M| vmcase(OP_GETUPVAL) { ------------------ | | 14| 2.40M|#define vmcase(l) L_##l: ------------------ 1239| 2.40M| StkId ra = RA(i); ------------------ | | 1059| 2.40M|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 2.40M|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 2.40M|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 2.40M|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 2.40M|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1240| 2.40M| int b = GETARG_B(i); ------------------ | | 128| 2.40M|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 2.40M|#define check_exp(c,e) (e) | | ------------------ ------------------ 1241| 2.40M| setobj2s(L, ra, cl->upvals[b]->v.p); ------------------ | | 131| 2.40M|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 2.40M| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 2.40M| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 2.40M|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 2.40M| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 2.40M| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 2.40M|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 2.40M| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 2.40M|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1242| 2.40M| vmbreak; ------------------ | | 16| 2.40M|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 2.40M|#define vmfetch() { \ | | | | 1134| 2.40M| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 2.40M|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 2.40M|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 2.40M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 2.40M| i = *(pc++); \ | | | | 1139| 2.40M|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 2.40M|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1243| 2.40M| } 1244| 2.40M| vmcase(OP_SETUPVAL) { ------------------ | | 14| 64|#define vmcase(l) L_##l: ------------------ 1245| 64| StkId ra = RA(i); ------------------ | | 1059| 64|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 64|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 64|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 64|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 64|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1246| 64| UpVal *uv = cl->upvals[GETARG_B(i)]; ------------------ | | 128| 64|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 64|#define check_exp(c,e) (e) | | ------------------ ------------------ 1247| 64| setobj(L, uv->v.p, s2v(ra)); ------------------ | | 119| 64| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | 120| 64| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | ------------------ | | | | 114| 64|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ | | 121| 64| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 107| 64| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | ------------------ | | | | | | 116| 64|#define lua_longassert(c) ((void)0) | | | | ------------------ | | | | 108| 64| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | ------------------ | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | ------------------ | | | | 114| 64|#define lua_assert(c) ((void)0) | | ------------------ ------------------ 1248| 64| luaC_barrier(L, uv, s2v(ra)); ------------------ | | 179| 64|#define luaC_barrier(L,p,v) ( \ | | 180| 64| iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 64|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 64|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 64|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 0, False: 64] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 175| 0|#define luaC_objbarrier(L,p,o) ( \ | | | | 176| 0| (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? \ | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 177| 0| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrier(L,p,gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 64|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 64|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1249| 64| vmbreak; ------------------ | | 16| 64|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 64|#define vmfetch() { \ | | | | 1134| 64| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 64|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 64|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 64] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 64| i = *(pc++); \ | | | | 1139| 64|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 64|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1250| 64| } 1251| 716k| vmcase(OP_GETTABUP) { ------------------ | | 14| 716k|#define vmcase(l) L_##l: ------------------ 1252| 716k| StkId ra = RA(i); ------------------ | | 1059| 716k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 716k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 716k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 716k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 716k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1253| 716k| const TValue *slot; 1254| 716k| TValue *upval = cl->upvals[GETARG_B(i)]->v.p; ------------------ | | 128| 716k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 716k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1255| 716k| TValue *rc = KC(i); ------------------ | | 1065| 716k|#define KC(i) (k+GETARG_C(i)) | | ------------------ | | | | 132| 716k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 716k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1256| 716k| TString *key = tsvalue(rc); /* key must be a string */ ------------------ | | 369| 716k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 716k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1257| 716k| if (luaV_fastget(L, upval, key, slot, luaH_getshortstr)) { ------------------ | | 86| 716k| (!ttistable(t) \ | | ------------------ | | | | 682| 716k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 716k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 716k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 275k, False: 441k] | | | Branch (86:4): [True: 0, False: 716k] | | ------------------ | | 87| 716k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 716k| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 684| 716k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 716k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 716k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 716k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 716k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 716k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 716k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 716k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1258| 275k| setobj2s(L, ra, slot); ------------------ | | 131| 275k|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 275k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 275k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 275k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 275k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 275k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 275k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 275k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 275k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1259| 275k| } 1260| 441k| else 1261| 441k| Protect(luaV_finishget(L, upval, rc, ra, slot)); ------------------ | | 1114| 441k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 441k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 441k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 441k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1262| 716k| vmbreak; ------------------ | | 16| 716k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 716k|#define vmfetch() { \ | | | | 1134| 716k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 716k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 716k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 716k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 716k| i = *(pc++); \ | | | | 1139| 716k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 716k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1263| 716k| } 1264| 716k| vmcase(OP_GETTABLE) { ------------------ | | 14| 248k|#define vmcase(l) L_##l: ------------------ 1265| 248k| StkId ra = RA(i); ------------------ | | 1059| 248k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 248k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 248k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 248k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 248k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1266| 248k| const TValue *slot; 1267| 248k| TValue *rb = vRB(i); ------------------ | | 1061| 248k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 248k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1268| 248k| TValue *rc = vRC(i); ------------------ | | 1064| 248k|#define vRC(i) s2v(RC(i)) | | ------------------ | | | | 172| 248k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1269| 248k| lua_Unsigned n; 1270| | if (ttisinteger(rc) /* fast track for integers? */ ------------------ | | 328| 248k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 496k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 248k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 248k, False: 4] | | | | ------------------ | | ------------------ ------------------ | Branch (1270:13): [True: 248k, False: 10] ------------------ 1271| 248k| ? (cast_void(n = ivalue(rc)), luaV_fastgeti(L, rb, n, slot)) ------------------ | | 138| 248k|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 248k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ ? (cast_void(n = ivalue(rc)), luaV_fastgeti(L, rb, n, slot)) ------------------ | | 97| 248k| (!ttistable(t) \ | | ------------------ | | | | 682| 248k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 248k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 248k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (97:4): [True: 0, False: 248k] | | ------------------ | | 98| 248k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 99| 248k| : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 152| 248k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 684| 248k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 248k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (99:14): [True: 143k, False: 105k] | | ------------------ | | 100| 248k| ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 684| 143k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 143k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 684| 105k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 105k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 101| 248k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 248k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 248k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 248k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 248k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 248k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1272| 248k| : luaV_fastget(L, rb, rc, slot, luaH_get)) { ------------------ | | 86| 4| (!ttistable(t) \ | | ------------------ | | | | 682| 4|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 4|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 4|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:4): [True: 0, False: 4] | | ------------------ | | 87| 4| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 4| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 684| 4|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 4|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 4| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 4|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 4|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 4|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 4|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 4|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1273| 248k| setobj2s(L, ra, slot); ------------------ | | 131| 248k|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 248k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 248k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 248k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 248k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 248k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 248k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 248k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 248k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1274| 248k| } 1275| 10| else 1276| 10| Protect(luaV_finishget(L, rb, rc, ra, slot)); ------------------ | | 1114| 10|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 10|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 10|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 10|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1277| 248k| vmbreak; ------------------ | | 16| 248k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 248k|#define vmfetch() { \ | | | | 1134| 248k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 248k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 248k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 248k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 248k| i = *(pc++); \ | | | | 1139| 248k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 248k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1278| 248k| } 1279| 744k| vmcase(OP_GETI) { ------------------ | | 14| 744k|#define vmcase(l) L_##l: ------------------ 1280| 744k| StkId ra = RA(i); ------------------ | | 1059| 744k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 744k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 744k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 744k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 744k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1281| 744k| const TValue *slot; 1282| 744k| TValue *rb = vRB(i); ------------------ | | 1061| 744k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 744k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1283| 744k| int c = GETARG_C(i); ------------------ | | 132| 744k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 744k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1284| 744k| if (luaV_fastgeti(L, rb, c, slot)) { ------------------ | | 97| 744k| (!ttistable(t) \ | | ------------------ | | | | 682| 744k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 744k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 744k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (97:3): [True: 744k, False: 20] | | | Branch (97:4): [True: 0, False: 744k] | | ------------------ | | 98| 744k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 99| 744k| : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 152| 744k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 684| 744k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 744k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (99:14): [True: 321k, False: 423k] | | ------------------ | | 100| 744k| ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 684| 321k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 321k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 684| 423k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 423k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 101| 744k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 744k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 744k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 744k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 744k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 744k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1285| 744k| setobj2s(L, ra, slot); ------------------ | | 131| 744k|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 744k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 744k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 744k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 744k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 744k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 744k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 744k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 744k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1286| 744k| } 1287| 20| else { 1288| 20| TValue key; 1289| 20| setivalue(&key, c); ------------------ | | 345| 20| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 20|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 20|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1290| 20| Protect(luaV_finishget(L, rb, &key, ra, slot)); ------------------ | | 1114| 20|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 20|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 20|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 20|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1291| 20| } 1292| 744k| vmbreak; ------------------ | | 16| 744k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 744k|#define vmfetch() { \ | | | | 1134| 744k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 744k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 744k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 744k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 744k| i = *(pc++); \ | | | | 1139| 744k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 744k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1293| 744k| } 1294| 744k| vmcase(OP_GETFIELD) { ------------------ | | 14| 1|#define vmcase(l) L_##l: ------------------ 1295| 1| StkId ra = RA(i); ------------------ | | 1059| 1|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 1|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1296| 1| const TValue *slot; 1297| 1| TValue *rb = vRB(i); ------------------ | | 1061| 1|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 1|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1298| 1| TValue *rc = KC(i); ------------------ | | 1065| 1|#define KC(i) (k+GETARG_C(i)) | | ------------------ | | | | 132| 1|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1299| 1| TString *key = tsvalue(rc); /* key must be a string */ ------------------ | | 369| 1|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 1|#define check_exp(c,e) (e) | | ------------------ ------------------ 1300| 1| if (luaV_fastget(L, rb, key, slot, luaH_getshortstr)) { ------------------ | | 86| 1| (!ttistable(t) \ | | ------------------ | | | | 682| 1|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 1|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 1|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 1] | | | Branch (86:4): [True: 0, False: 1] | | ------------------ | | 87| 1| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 1| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 684| 1|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 1| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 1|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 1|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 1|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 1|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 1|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1301| 0| setobj2s(L, ra, slot); ------------------ | | 131| 0|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1302| 0| } 1303| 1| else 1304| 1| Protect(luaV_finishget(L, rb, rc, ra, slot)); ------------------ | | 1114| 1|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 1|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 1|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 1|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1305| 1| vmbreak; ------------------ | | 16| 1|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 1|#define vmfetch() { \ | | | | 1134| 1| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 1|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 1|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 1| i = *(pc++); \ | | | | 1139| 1|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1306| 1| } 1307| 504k| vmcase(OP_SETTABUP) { ------------------ | | 14| 504k|#define vmcase(l) L_##l: ------------------ 1308| 504k| const TValue *slot; 1309| 504k| TValue *upval = cl->upvals[GETARG_A(i)]->v.p; ------------------ | | 125| 504k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | ------------------ | | | | 121| 504k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | ------------------ | | | | | | 141| 504k|#define cast_int(i) cast(int, (i)) | | | | | | ------------------ | | | | | | | | 136| 504k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1310| 504k| TValue *rb = KB(i); ------------------ | | 1062| 504k|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 504k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 115| 504k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1311| 504k| TValue *rc = RKC(i); ------------------ | | 1066| 504k|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 504k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 115| 504k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 5.24k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 5.24k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 499k|#define s2v(o) (&(o)->val) | | ------------------ | | | Branch (1066:17): [True: 5.24k, False: 499k] | | ------------------ ------------------ 1312| 504k| TString *key = tsvalue(rb); /* key must be a string */ ------------------ | | 369| 504k|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 504k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1313| 504k| if (luaV_fastget(L, upval, key, slot, luaH_getshortstr)) { ------------------ | | 86| 504k| (!ttistable(t) \ | | ------------------ | | | | 682| 504k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 504k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 504k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 324k, False: 180k] | | | Branch (86:4): [True: 0, False: 504k] | | ------------------ | | 87| 504k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 504k| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 684| 504k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 504k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 504k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 504k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 504k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 504k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 504k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 504k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1314| 324k| luaV_finishfastset(L, upval, slot, rc); ------------------ | | 109| 324k| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 324k|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 324k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 324k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 324k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 324k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 324k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 116| 324k|#define lua_longassert(c) ((void)0) | | | | | | | | ------------------ | | | | | | | | 108| 324k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 114| 324k|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 324k| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 324k|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 324k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 324k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 324k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 324k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 55.2k, False: 269k] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 55.2k|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 55.2k| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 55.2k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 55.2k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 110k|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 14, False: 55.2k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 87| 14|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 62| 14|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 12, False: 2] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 55.2k|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 55.2k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 269k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 269k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1315| 324k| } 1316| 180k| else 1317| 180k| Protect(luaV_finishset(L, upval, rb, rc, slot)); ------------------ | | 1114| 180k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 180k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 180k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 180k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1318| 504k| vmbreak; ------------------ | | 16| 504k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 504k|#define vmfetch() { \ | | | | 1134| 504k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 504k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 504k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 504k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 504k| i = *(pc++); \ | | | | 1139| 504k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 504k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1319| 504k| } 1320| 816k| vmcase(OP_SETTABLE) { ------------------ | | 14| 816k|#define vmcase(l) L_##l: ------------------ 1321| 816k| StkId ra = RA(i); ------------------ | | 1059| 816k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 816k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 816k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 816k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 816k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1322| 816k| const TValue *slot; 1323| 816k| TValue *rb = vRB(i); /* key (table is in 'ra') */ ------------------ | | 1061| 816k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 816k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1324| 816k| TValue *rc = RKC(i); /* value */ ------------------ | | 1066| 816k|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 816k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 115| 816k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 25.4k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 25.4k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 791k|#define s2v(o) (&(o)->val) | | ------------------ | | | Branch (1066:17): [True: 25.4k, False: 791k] | | ------------------ ------------------ 1325| 816k| lua_Unsigned n; 1326| | if (ttisinteger(rb) /* fast track for integers? */ ------------------ | | 328| 816k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 1.63M|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 816k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 718k, False: 97.7k] | | | | ------------------ | | ------------------ ------------------ | Branch (1326:13): [True: 383k, False: 433k] ------------------ 1327| 816k| ? (cast_void(n = ivalue(rb)), luaV_fastgeti(L, s2v(ra), n, slot)) ------------------ | | 138| 718k|#define cast_void(i) cast(void, (i)) | | ------------------ | | | | 136| 718k|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ ? (cast_void(n = ivalue(rb)), luaV_fastgeti(L, s2v(ra), n, slot)) ------------------ | | 97| 718k| (!ttistable(t) \ | | ------------------ | | | | 682| 718k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 718k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 718k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (97:4): [True: 2, False: 718k] | | ------------------ | | 98| 718k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 99| 718k| : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 152| 718k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 684| 718k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 718k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (99:14): [True: 252k, False: 466k] | | ------------------ | | 100| 718k| ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 684| 252k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 252k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 684| 466k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 466k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 101| 718k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 718k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 718k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 718k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 718k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 718k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1328| 816k| : luaV_fastget(L, s2v(ra), rb, slot, luaH_get)) { ------------------ | | 86| 97.7k| (!ttistable(t) \ | | ------------------ | | | | 682| 97.7k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 97.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 97.7k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:4): [True: 0, False: 97.7k] | | ------------------ | | 87| 97.7k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 97.7k| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 684| 97.7k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 97.7k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 97.7k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 97.7k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 97.7k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 97.7k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 97.7k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 97.7k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1329| 383k| luaV_finishfastset(L, s2v(ra), slot, rc); ------------------ | | 109| 383k| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 383k|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 383k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 383k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 383k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 383k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 383k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 116| 383k|#define lua_longassert(c) ((void)0) | | | | | | | | ------------------ | | | | | | | | 108| 383k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 114| 383k|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 383k| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 383k|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 383k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 383k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 383k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 383k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 14, False: 383k] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 14|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 14| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 14|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 14|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 28|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 0, False: 14] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 14|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 14|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 383k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 383k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1330| 383k| } 1331| 433k| else 1332| 433k| Protect(luaV_finishset(L, s2v(ra), rb, rc, slot)); ------------------ | | 1114| 433k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 433k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 433k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 433k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1333| 816k| vmbreak; ------------------ | | 16| 816k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 816k|#define vmfetch() { \ | | | | 1134| 816k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 816k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 816k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 816k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 816k| i = *(pc++); \ | | | | 1139| 816k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 816k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1334| 816k| } 1335| 816k| vmcase(OP_SETI) { ------------------ | | 14| 147k|#define vmcase(l) L_##l: ------------------ 1336| 147k| StkId ra = RA(i); ------------------ | | 1059| 147k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 147k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 147k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 147k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 147k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1337| 147k| const TValue *slot; 1338| 147k| int c = GETARG_B(i); ------------------ | | 128| 147k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 147k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1339| 147k| TValue *rc = RKC(i); ------------------ | | 1066| 147k|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 147k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 115| 147k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 147k|#define s2v(o) (&(o)->val) | | ------------------ | | | Branch (1066:17): [True: 0, False: 147k] | | ------------------ ------------------ 1340| 147k| if (luaV_fastgeti(L, s2v(ra), c, slot)) { ------------------ | | 97| 147k| (!ttistable(t) \ | | ------------------ | | | | 682| 147k|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 147k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 147k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (97:3): [True: 137k, False: 9.21k] | | | Branch (97:4): [True: 0, False: 147k] | | ------------------ | | 98| 147k| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 99| 147k| : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 152| 147k|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \ | | ------------------ | | | | 684| 147k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 147k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (99:14): [True: 137k, False: 9.22k] | | ------------------ | | 100| 147k| ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 684| 137k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 137k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \ | | ------------------ | | | | 684| 9.22k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 9.22k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 101| 147k| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 147k|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 147k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 147k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 147k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 147k|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1341| 137k| luaV_finishfastset(L, s2v(ra), slot, rc); ------------------ | | 109| 137k| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 137k|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 137k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 137k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 137k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 137k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 137k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 116| 137k|#define lua_longassert(c) ((void)0) | | | | | | | | ------------------ | | | | | | | | 108| 137k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 114| 137k|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 137k| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 137k|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 137k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 137k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 137k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 137k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 137k] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 0|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 0| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 137k|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 137k|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1342| 137k| } 1343| 9.21k| else { 1344| 9.21k| TValue key; 1345| 9.21k| setivalue(&key, c); ------------------ | | 345| 9.21k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 9.21k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 9.21k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1346| 9.21k| Protect(luaV_finishset(L, s2v(ra), &key, rc, slot)); ------------------ | | 1114| 9.21k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 9.21k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 9.21k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 9.21k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1347| 9.21k| } 1348| 147k| vmbreak; ------------------ | | 16| 147k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 147k|#define vmfetch() { \ | | | | 1134| 147k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 147k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 147k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 147k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 147k| i = *(pc++); \ | | | | 1139| 147k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 147k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1349| 147k| } 1350| 147k| vmcase(OP_SETFIELD) { ------------------ | | 14| 1|#define vmcase(l) L_##l: ------------------ 1351| 1| StkId ra = RA(i); ------------------ | | 1059| 1|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 1|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 1|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 1|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 1|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1352| 1| const TValue *slot; 1353| 1| TValue *rb = KB(i); ------------------ | | 1062| 1|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 1|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1354| 1| TValue *rc = RKC(i); ------------------ | | 1066| 1|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 1|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 1|#define s2v(o) (&(o)->val) | | ------------------ | | | Branch (1066:17): [True: 0, False: 1] | | ------------------ ------------------ 1355| 1| TString *key = tsvalue(rb); /* key must be a string */ ------------------ | | 369| 1|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 1|#define check_exp(c,e) (e) | | ------------------ ------------------ 1356| 1| if (luaV_fastget(L, s2v(ra), key, slot, luaH_getshortstr)) { ------------------ | | 86| 1| (!ttistable(t) \ | | ------------------ | | | | 682| 1|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 1|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 1|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 1] | | | Branch (86:4): [True: 0, False: 1] | | ------------------ | | 87| 1| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 1| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 684| 1|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 1| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 1|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 1|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 1|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 1|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 1|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1357| 0| luaV_finishfastset(L, s2v(ra), slot, rc); ------------------ | | 109| 0| { setobj2t(L, cast(TValue *,slot), v); \ | | ------------------ | | | | 137| 0|#define setobj2t setobj | | | | ------------------ | | | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | | | ------------------ | | | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | | | ------------------ | | | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | | | ------------------ | | | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | | | ------------------ | | | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 110| 0| luaC_barrierback(L, gcvalue(t), v); } | | ------------------ | | | | 185| 0|#define luaC_barrierback(L,p,v) ( \ | | | | 186| 0| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 300| 0|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | | | ------------------ | | | | | | | | 298| 0|#define BIT_ISCOLLECTABLE (1 << 6) | | | | | | ------------------ | | | | | | | Branch (300:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 182| 0|#define luaC_objbarrierback(L,p,o) ( \ | | | | | | 183| 0| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 88| 0|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | | | ------------------ | | | | | | | | | | 67| 0|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | | | ------------------ | | | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | | | ------------------ | | | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | | | ------------------ | | | | | | 138| 0|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1358| 0| } 1359| 1| else 1360| 1| Protect(luaV_finishset(L, s2v(ra), rb, rc, slot)); ------------------ | | 1114| 1|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 1|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 1|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 1|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1361| 1| vmbreak; ------------------ | | 16| 1|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 1|#define vmfetch() { \ | | | | 1134| 1| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 1|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 1|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 1| i = *(pc++); \ | | | | 1139| 1|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1362| 1| } 1363| 119k| vmcase(OP_NEWTABLE) { ------------------ | | 14| 119k|#define vmcase(l) L_##l: ------------------ 1364| 119k| StkId ra = RA(i); ------------------ | | 1059| 119k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 119k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 119k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 119k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 119k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1365| 119k| int b = GETARG_B(i); /* log2(hash size) + 1 */ ------------------ | | 128| 119k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 119k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1366| 119k| int c = GETARG_C(i); /* array size */ ------------------ | | 132| 119k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 119k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1367| 119k| Table *t; 1368| 119k| if (b > 0) ------------------ | Branch (1368:13): [True: 0, False: 119k] ------------------ 1369| 0| b = 1 << (b - 1); /* size is 2^(b - 1) */ 1370| 119k| lua_assert((!TESTARG_k(i)) == (GETARG_Ax(*pc) == 0)); ------------------ | | 114| 119k|#define lua_assert(c) ((void)0) ------------------ 1371| 119k| if (TESTARG_k(i)) /* non-zero extra argument? */ ------------------ | | 136| 119k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 115| 119k|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:25): [True: 0, False: 119k] | | | | ------------------ | | ------------------ ------------------ 1372| 0| c += GETARG_Ax(*pc) * (MAXARG_C + 1); /* add it to size */ ------------------ | | 143| 0|#define GETARG_Ax(i) check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ c += GETARG_Ax(*pc) * (MAXARG_C + 1); /* add it to size */ ------------------ | | 97| 0|#define MAXARG_C ((1<top.p = ra + 1; /* correct top in case of emergency GC */ 1375| 119k| t = luaH_new(L); /* memory allocation */ 1376| 119k| sethvalue2s(L, ra, t); ------------------ | | 691| 119k|#define sethvalue2s(L,o,h) sethvalue(L,s2v(o),h) | | ------------------ | | | | 687| 119k| { TValue *io = (obj); Table *x_ = (x); \ | | | | 688| 119k| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 72| 119k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 390| 119k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 119k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VTABLE)); \ | | | | ------------------ | | | | | | 114| 119k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 689| 119k| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 119k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 119k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 119k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 1377| 119k| if (b != 0 || c != 0) ------------------ | Branch (1377:13): [True: 0, False: 119k] | Branch (1377:23): [True: 119k, False: 0] ------------------ 1378| 119k| luaH_resize(L, t, c, b); /* idem */ 1379| 119k| checkGC(L, ra + 1); ------------------ | | 1127| 119k| { luaC_condGC(L, (savepc(L), L->top.p = (c)), \ | | ------------------ | | | | 168| 119k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 119k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 14, False: 119k] | | | | ------------------ | | | | 169| 119k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 119k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 1128| 119k| updatetrap(ci)); \ | | 1129| 119k| luai_threadyield(L); } | | ------------------ | | | | 273| 119k|#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 265| 119k|#define lua_unlock(L) ((void) 0) | | | | ------------------ | | | | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 264| 119k|#define lua_lock(L) ((void) 0) | | | | ------------------ | | ------------------ ------------------ 1380| 119k| vmbreak; ------------------ | | 16| 119k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 119k|#define vmfetch() { \ | | | | 1134| 119k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 119k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 119k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 119k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 119k| i = *(pc++); \ | | | | 1139| 119k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 119k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1381| 119k| } 1382| 119k| vmcase(OP_SELF) { ------------------ | | 14| 16|#define vmcase(l) L_##l: ------------------ 1383| 16| StkId ra = RA(i); ------------------ | | 1059| 16|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 16|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 16|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 16|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 16|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1384| 16| const TValue *slot; 1385| 16| TValue *rb = vRB(i); ------------------ | | 1061| 16|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 16|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1386| 16| TValue *rc = RKC(i); ------------------ | | 1066| 16|#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 136| 16|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | | | ------------------ | | | | | | 115| 16|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 132| 16|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 16|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i))) | | ------------------ | | | | 172| 0|#define s2v(o) (&(o)->val) | | ------------------ | | | Branch (1066:17): [True: 16, False: 0] | | ------------------ ------------------ 1387| 16| TString *key = tsvalue(rc); /* key must be a string */ ------------------ | | 369| 16|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ 1388| 16| setobj2s(L, ra + 1, rb); ------------------ | | 131| 16|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 16| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 16| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 16|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 16| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 16| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 16|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 16| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 16|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1389| 16| if (luaV_fastget(L, rb, key, slot, luaH_getstr)) { ------------------ | | 86| 16| (!ttistable(t) \ | | ------------------ | | | | 682| 16|#define ttistable(o) checktag((o), ctb(LUA_VTABLE)) | | | | ------------------ | | | | | | 91| 16|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 16|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (86:3): [True: 0, False: 16] | | | Branch (86:4): [True: 0, False: 16] | | ------------------ | | 87| 16| ? (slot = NULL, 0) /* not a table; 'slot' is NULL and result is 0 */ \ | | 88| 16| : (slot = f(hvalue(t), k), /* else, do raw access */ \ | | ------------------ | | | | 684| 16|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | | | ------------------ | | | | | | 115| 16|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 89| 16| !isempty(slot))) /* result not empty? */ | | ------------------ | | | | 217| 16|#define isempty(v) ttisnil(v) | | | | ------------------ | | | | | | 193| 16|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | | | ------------------ | | | | | | | | 92| 16|#define checktype(o,t) (ttype(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 87| 16|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 80| 16|#define novariant(t) ((t) & 0x0F) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1390| 0| setobj2s(L, ra, slot); ------------------ | | 131| 0|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1391| 0| } 1392| 16| else 1393| 16| Protect(luaV_finishget(L, rb, rc, ra, slot)); ------------------ | | 1114| 16|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 16|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 16|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 16|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1394| 16| vmbreak; ------------------ | | 16| 16|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 16|#define vmfetch() { \ | | | | 1134| 16| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 16|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 16|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 16] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 16| i = *(pc++); \ | | | | 1139| 16|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 16|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1395| 16| } 1396| 18.4k| vmcase(OP_ADDI) { ------------------ | | 14| 18.4k|#define vmcase(l) L_##l: ------------------ 1397| 18.4k| op_arithI(L, l_addi, luai_numadd); ------------------ | | 900| 18.4k|#define op_arithI(L,iop,fop) { \ | | 901| 18.4k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 18.4k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 18.4k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 18.4k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 18.4k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 18.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 902| 18.4k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 18.4k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 18.4k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 903| 18.4k| int imm = GETARG_sC(i); \ | | ------------------ | | | | 133| 18.4k|#define GETARG_sC(i) sC2int(GETARG_C(i)) | | | | ------------------ | | | | | | 101| 18.4k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 18.4k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 18.4k|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 18.4k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 905| 18.4k| lua_Integer iv1 = ivalue(v1); \ | | ------------------ | | | | 333| 18.4k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 18.4k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 906| 18.4k| pc++; setivalue(s2v(ra), iop(L, iv1, imm)); \ | | ------------------ | | | | 345| 18.4k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 18.4k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 18.4k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 907| 18.4k| } \ | | 908| 18.4k| else if (ttisfloat(v1)) { \ | | ------------------ | | | | 327| 0|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 909| 0| lua_Number nb = fltvalue(v1); \ | | ------------------ | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 910| 0| lua_Number fimm = cast_num(imm); \ | | ------------------ | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 911| 0| pc++; setfltvalue(s2v(ra), fop(L, nb, fimm)); \ | | ------------------ | | | | 339| 0| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | ------------------ | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 912| 0| }} ------------------ 1398| 18.4k| vmbreak; ------------------ | | 16| 18.4k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 18.4k|#define vmfetch() { \ | | | | 1134| 18.4k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 18.4k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 18.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 18.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 18.4k| i = *(pc++); \ | | | | 1139| 18.4k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 18.4k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1399| 18.4k| } 1400| 873k| vmcase(OP_ADDK) { ------------------ | | 14| 873k|#define vmcase(l) L_##l: ------------------ 1401| 873k| op_arithK(L, l_addi, luai_numadd); ------------------ | | 970| 873k|#define op_arithK(L,iop,fop) { \ | | 971| 873k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 873k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 873k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 972| 873k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 873k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 873k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 873k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 873k|#define lua_assert(c) ((void)0) | | ------------------ | | 973| 873k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 873k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 873k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 873k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 873k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 873k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 873k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 873k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 873k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 873k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 1.74M|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 873k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 515k, False: 358k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 515k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 515k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 515k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 0, False: 515k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 0| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 953| 0| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 0| } \ | | | | 955| 873k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 873k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 873k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 873k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 1.74M| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 873k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 873k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 873k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 358k, False: 515k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 358k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 358k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 873k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 1.74M| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 515k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 515k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 515k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 515k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 515k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 515k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 873k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 873k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 873k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 873k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 873k, False: 5] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 873k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 873k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 873k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 873k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 5|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 5|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 5|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 5, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 5|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 5|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 873k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 873k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 873k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 873k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 873k| }} | | | | ------------------ | | ------------------ ------------------ 1402| 873k| vmbreak; ------------------ | | 16| 873k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 873k|#define vmfetch() { \ | | | | 1134| 873k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 873k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 873k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 873k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 873k| i = *(pc++); \ | | | | 1139| 873k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 873k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1403| 873k| } 1404| 873k| vmcase(OP_SUBK) { ------------------ | | 14| 1.33k|#define vmcase(l) L_##l: ------------------ 1405| 1.33k| op_arithK(L, l_subi, luai_numsub); ------------------ | | 970| 1.33k|#define op_arithK(L,iop,fop) { \ | | 971| 1.33k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 1.33k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 1.33k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 972| 1.33k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 1.33k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 1.33k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 1.33k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 1.33k|#define lua_assert(c) ((void)0) | | ------------------ | | 973| 1.33k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 1.33k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 1.33k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 1.33k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 1.33k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 1.33k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 1.33k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 1.33k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 1.33k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 1.33k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 2.67k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 1.33k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 30, False: 1.30k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 30|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 30|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 30|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 0, False: 30] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 0| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 953| 0| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 0| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 0| } \ | | | | 955| 1.33k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 1.33k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 1.33k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 1.33k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 2.67k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 1.33k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 1.33k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 1.33k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 1.30k, False: 30] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 1.30k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 1.30k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 1.33k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 2.67k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 30|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 30|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 30|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 30, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 30|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 30|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 1.33k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 1.33k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 1.33k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 1.33k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 30, False: 1.30k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 30|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 30|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 1.33k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 1.33k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 1.30k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 1.30k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 1.30k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 1.30k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 1.30k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 1.30k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 1.33k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 1.33k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 1.33k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 1.33k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 1.33k| }} | | | | ------------------ | | ------------------ ------------------ 1406| 1.33k| vmbreak; ------------------ | | 16| 1.33k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 1.33k|#define vmfetch() { \ | | | | 1134| 1.33k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 1.33k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 1.33k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 1.33k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 1.33k| i = *(pc++); \ | | | | 1139| 1.33k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.33k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1407| 1.33k| } 1408| 36.8k| vmcase(OP_MULK) { ------------------ | | 14| 36.8k|#define vmcase(l) L_##l: ------------------ 1409| 36.8k| op_arithK(L, l_muli, luai_nummul); ------------------ | | 970| 36.8k|#define op_arithK(L,iop,fop) { \ | | 971| 36.8k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 36.8k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 36.8k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 972| 36.8k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 36.8k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 36.8k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 36.8k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 36.8k|#define lua_assert(c) ((void)0) | | ------------------ | | 973| 36.8k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 36.8k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 36.8k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 36.8k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 36.8k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 36.8k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 36.8k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 36.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 36.8k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 36.8k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 73.6k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 36.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 36.8k, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 36.8k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 36.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 36.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 36.8k, False: 5] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 36.8k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 36.8k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 36.8k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 36.8k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 36.8k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 953| 36.8k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 36.8k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 36.8k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 36.8k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 36.8k| } \ | | | | 955| 36.8k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 6|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 6| lua_Number n1; lua_Number n2; \ | | | | | | 921| 6| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 12| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 6|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 6|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 6|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 1, False: 5] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 1|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 6, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 12| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 5|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 5|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 5|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 5, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 5|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 5|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 6| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 6|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 6|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 6|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 5, False: 1] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 5|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 5|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 6, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 6| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 1|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 1|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 1|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 1, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 1|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 1|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 6| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 6| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 6|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 6|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 6| }} | | | | ------------------ | | ------------------ ------------------ 1410| 36.8k| vmbreak; ------------------ | | 16| 36.8k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 36.8k|#define vmfetch() { \ | | | | 1134| 36.8k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 36.8k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 36.8k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 36.8k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 36.8k| i = *(pc++); \ | | | | 1139| 36.8k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 36.8k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1411| 36.8k| } 1412| 64.4k| vmcase(OP_MODK) { ------------------ | | 14| 64.4k|#define vmcase(l) L_##l: ------------------ 1413| 64.4k| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1107| 64.4k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1100| 64.4k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1414| 64.4k| op_arithK(L, luaV_mod, luaV_modf); ------------------ | | 970| 64.4k|#define op_arithK(L,iop,fop) { \ | | 971| 64.4k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 64.4k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 64.4k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 972| 64.4k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 64.4k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 64.4k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 64.4k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 64.4k|#define lua_assert(c) ((void)0) | | ------------------ | | 973| 64.4k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 64.4k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 64.4k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 64.4k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 64.4k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 64.4k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 64.4k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 64.4k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 64.4k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 64.4k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 128k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 64.4k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 27.5k, False: 36.8k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 27.5k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 27.5k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 27.5k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 27.5k, False: 3] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 27.5k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 27.5k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 27.5k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 27.5k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 27.5k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 953| 27.5k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 27.5k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 27.5k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 27.5k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 27.5k| } \ | | | | 955| 64.4k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 36.8k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 36.8k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 36.8k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 73.6k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 36.8k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 36.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 36.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 36.8k, False: 3] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 36.8k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 36.8k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 36.8k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 73.6k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 3|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 3|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 3|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 3, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 3|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 3|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 36.8k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 36.8k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 36.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 36.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 3, False: 36.8k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 3|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 3|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 36.8k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 36.8k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 36.8k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 36.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 36.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 36.8k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 36.8k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 36.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 36.8k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 36.8k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 36.8k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 36.8k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 36.8k| }} | | | | ------------------ | | ------------------ ------------------ 1415| 64.4k| vmbreak; ------------------ | | 16| 64.4k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 64.4k|#define vmfetch() { \ | | | | 1134| 64.4k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 64.4k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 64.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 64.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 64.4k| i = *(pc++); \ | | | | 1139| 64.4k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 64.4k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1416| 64.4k| } 1417| 64.9k| vmcase(OP_POWK) { ------------------ | | 14| 64.9k|#define vmcase(l) L_##l: ------------------ 1418| 64.9k| op_arithfK(L, luai_numpow); ------------------ | | 939| 64.9k|#define op_arithfK(L,fop) { \ | | 940| 64.9k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 64.9k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 64.9k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 64.9k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 64.9k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 64.9k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 941| 64.9k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 64.9k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 64.9k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 942| 64.9k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 64.9k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 64.9k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 64.9k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 64.9k|#define lua_assert(c) ((void)0) | | ------------------ | | 943| 64.9k| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 919| 64.9k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 920| 64.9k| lua_Number n1; lua_Number n2; \ | | | | 921| 64.9k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 129k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 64.9k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 64.9k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 64.9k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 0, False: 64.9k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 64.9k, False: 0] | | | | | | ------------------ | | | | | | 58| 129k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 64.9k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 64.9k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 64.9k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 64.9k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 64.9k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 64.9k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 64.9k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 64.9k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 64.9k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 64.9k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 0, False: 64.9k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 64.9k, False: 0] | | | | | | ------------------ | | | | | | 58| 64.9k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 64.9k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 64.9k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 64.9k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 64.9k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 64.9k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 64.9k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 922| 64.9k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | ------------------ | | | | | | 339| 129k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 72| 64.9k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 114| 64.9k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | | Branch (339:35): [True: 0, False: 64.9k] | | | | | | ------------------ | | | | ------------------ | | | | 923| 64.9k| }} | | ------------------ ------------------ 1419| 64.9k| vmbreak; ------------------ | | 16| 64.9k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 64.9k|#define vmfetch() { \ | | | | 1134| 64.9k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 64.9k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 64.9k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 64.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 64.9k| i = *(pc++); \ | | | | 1139| 64.9k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 64.9k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1420| 64.9k| } 1421| 64.9k| vmcase(OP_DIVK) { ------------------ | | 14| 64.3k|#define vmcase(l) L_##l: ------------------ 1422| 64.3k| op_arithfK(L, luai_numdiv); ------------------ | | 939| 64.3k|#define op_arithfK(L,fop) { \ | | 940| 64.3k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 64.3k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 64.3k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 64.3k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 64.3k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 64.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 941| 64.3k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 64.3k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 64.3k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 942| 64.3k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 64.3k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 64.3k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 64.3k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 64.3k|#define lua_assert(c) ((void)0) | | ------------------ | | 943| 64.3k| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 919| 64.3k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 920| 64.3k| lua_Number n1; lua_Number n2; \ | | | | 921| 64.3k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 128k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 64.3k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 64.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 64.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 0, False: 64.3k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 64.3k, False: 0] | | | | | | ------------------ | | | | | | 58| 128k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 64.3k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 64.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 64.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 64.3k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 64.3k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 64.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 64.3k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 64.3k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 64.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 64.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 0, False: 64.3k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 64.3k, False: 0] | | | | | | ------------------ | | | | | | 58| 64.3k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 64.3k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 64.3k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 64.3k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 64.3k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 64.3k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 64.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 922| 64.3k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | ------------------ | | | | | | 339| 64.3k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 72| 64.3k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 114| 64.3k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 923| 64.3k| }} | | ------------------ ------------------ 1423| 64.3k| vmbreak; ------------------ | | 16| 64.3k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 64.3k|#define vmfetch() { \ | | | | 1134| 64.3k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 64.3k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 64.3k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 64.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 64.3k| i = *(pc++); \ | | | | 1139| 64.3k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 64.3k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1424| 64.3k| } 1425| 64.3k| vmcase(OP_IDIVK) { ------------------ | | 14| 9.20k|#define vmcase(l) L_##l: ------------------ 1426| 9.20k| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1107| 9.20k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1100| 9.20k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1427| 9.20k| op_arithK(L, luaV_idiv, luai_numidiv); ------------------ | | 970| 9.20k|#define op_arithK(L,iop,fop) { \ | | 971| 9.20k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 9.20k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 9.20k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 972| 9.20k| TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 1065| 9.20k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 9.20k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 9.20k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \ | | ------------------ | | | | 114| 9.20k|#define lua_assert(c) ((void)0) | | ------------------ | | 973| 9.20k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 9.20k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 9.20k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 9.20k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 9.20k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 9.20k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 9.20k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 9.20k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 9.20k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 9.20k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 18.4k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 9.20k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 9.20k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 9.20k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 9.20k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 9.20k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 9.20k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 9.20k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 9.20k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 9.20k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 9.20k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 9.20k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 953| 9.20k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 9.20k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 9.20k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 9.20k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 9.20k| } \ | | | | 955| 9.20k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 0|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 0| lua_Number n1; lua_Number n2; \ | | | | | | 921| 0| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 0| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 0|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 0| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 0|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 0| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 0|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 0| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 0|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 0| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 0| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 0|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 0| }} | | | | ------------------ | | ------------------ ------------------ 1428| 9.20k| vmbreak; ------------------ | | 16| 9.20k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 9.20k|#define vmfetch() { \ | | | | 1134| 9.20k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 9.20k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 9.20k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 9.20k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 9.20k| i = *(pc++); \ | | | | 1139| 9.20k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 9.20k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1429| 9.20k| } 1430| 9.20k| vmcase(OP_BANDK) { ------------------ | | 14| 12|#define vmcase(l) L_##l: ------------------ 1431| 12| op_bitwiseK(L, l_band); ------------------ | | 979| 12|#define op_bitwiseK(L,op) { \ | | 980| 12| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 12|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 12|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 12|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 12|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 981| 12| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 12|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 12|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 982| 12| TValue *v2 = KC(i); \ | | ------------------ | | | | 1065| 12|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 12|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 12|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 983| 12| lua_Integer i1; \ | | 984| 12| lua_Integer i2 = ivalue(v2); \ | | ------------------ | | | | 333| 12|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 12|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 985| 12| if (tointegerns(v1, &i1)) { \ | | ------------------ | | | | 69| 12| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 687| 12|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 675| 12|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (675:25): [True: 12, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 12|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 12|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 12, False: 0] | | | | ------------------ | | | | 70| 12| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 986| 12| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 12| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 12|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 12|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 987| 12| }} ------------------ 1432| 12| vmbreak; ------------------ | | 16| 12|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 12|#define vmfetch() { \ | | | | 1134| 12| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 12|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 12|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 12] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 12| i = *(pc++); \ | | | | 1139| 12|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 12|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1433| 12| } 1434| 239k| vmcase(OP_BORK) { ------------------ | | 14| 239k|#define vmcase(l) L_##l: ------------------ 1435| 239k| op_bitwiseK(L, l_bor); ------------------ | | 979| 239k|#define op_bitwiseK(L,op) { \ | | 980| 239k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 239k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 239k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 239k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 239k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 239k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 981| 239k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 239k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 239k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 982| 239k| TValue *v2 = KC(i); \ | | ------------------ | | | | 1065| 239k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 239k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 239k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 983| 239k| lua_Integer i1; \ | | 984| 239k| lua_Integer i2 = ivalue(v2); \ | | ------------------ | | | | 333| 239k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 239k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 985| 239k| if (tointegerns(v1, &i1)) { \ | | ------------------ | | | | 69| 239k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 687| 239k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 675| 239k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (675:25): [True: 101k, False: 137k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 101k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 101k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 239k, False: 0] | | | | ------------------ | | | | 70| 239k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 137k|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 986| 239k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 239k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 239k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 239k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 987| 239k| }} ------------------ 1436| 239k| vmbreak; ------------------ | | 16| 239k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 239k|#define vmfetch() { \ | | | | 1134| 239k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 239k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 239k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 239k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 239k| i = *(pc++); \ | | | | 1139| 239k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 239k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1437| 239k| } 1438| 239k| vmcase(OP_BXORK) { ------------------ | | 14| 28.9k|#define vmcase(l) L_##l: ------------------ 1439| 28.9k| op_bitwiseK(L, l_bxor); ------------------ | | 979| 28.9k|#define op_bitwiseK(L,op) { \ | | 980| 28.9k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 28.9k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 28.9k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 28.9k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 28.9k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 28.9k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 981| 28.9k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 28.9k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 28.9k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 982| 28.9k| TValue *v2 = KC(i); \ | | ------------------ | | | | 1065| 28.9k|#define KC(i) (k+GETARG_C(i)) | | | | ------------------ | | | | | | 132| 28.9k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | | | ------------------ | | | | | | | | 115| 28.9k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 983| 28.9k| lua_Integer i1; \ | | 984| 28.9k| lua_Integer i2 = ivalue(v2); \ | | ------------------ | | | | 333| 28.9k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 28.9k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 985| 28.9k| if (tointegerns(v1, &i1)) { \ | | ------------------ | | | | 69| 28.9k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 687| 28.9k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 675| 28.9k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (675:25): [True: 27.6k, False: 1.32k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 27.6k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 27.6k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 28.9k, False: 0] | | | | ------------------ | | | | 70| 28.9k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 1.32k|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 986| 28.9k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 28.9k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 28.9k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 28.9k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 987| 28.9k| }} ------------------ 1440| 28.9k| vmbreak; ------------------ | | 16| 28.9k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 28.9k|#define vmfetch() { \ | | | | 1134| 28.9k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 28.9k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 28.9k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 28.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 28.9k| i = *(pc++); \ | | | | 1139| 28.9k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 28.9k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1441| 28.9k| } 1442| 64.3k| vmcase(OP_SHRI) { ------------------ | | 14| 64.3k|#define vmcase(l) L_##l: ------------------ 1443| 64.3k| StkId ra = RA(i); ------------------ | | 1059| 64.3k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 64.3k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 64.3k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 64.3k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 64.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1444| 64.3k| TValue *rb = vRB(i); ------------------ | | 1061| 64.3k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 64.3k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1445| 64.3k| int ic = GETARG_sC(i); ------------------ | | 133| 64.3k|#define GETARG_sC(i) sC2int(GETARG_C(i)) | | ------------------ | | | | 101| 64.3k|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 64.3k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 64.3k|#define MAXARG_C ((1<value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 64.3k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1449| 64.3k| } 1450| 64.3k| vmbreak; ------------------ | | 16| 64.3k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 64.3k|#define vmfetch() { \ | | | | 1134| 64.3k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 64.3k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 64.3k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 64.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 64.3k| i = *(pc++); \ | | | | 1139| 64.3k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 64.3k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1451| 64.3k| } 1452| 64.3k| vmcase(OP_SHLI) { ------------------ | | 14| 30.1k|#define vmcase(l) L_##l: ------------------ 1453| 30.1k| StkId ra = RA(i); ------------------ | | 1059| 30.1k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 30.1k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 30.1k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 30.1k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 30.1k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1454| 30.1k| TValue *rb = vRB(i); ------------------ | | 1061| 30.1k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 30.1k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1455| 30.1k| int ic = GETARG_sC(i); ------------------ | | 133| 30.1k|#define GETARG_sC(i) sC2int(GETARG_C(i)) | | ------------------ | | | | 101| 30.1k|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 30.1k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 30.1k|#define MAXARG_C ((1<value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 30.1k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1459| 30.1k| } 1460| 30.1k| vmbreak; ------------------ | | 16| 30.1k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 30.1k|#define vmfetch() { \ | | | | 1134| 30.1k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 30.1k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 30.1k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 30.1k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 30.1k| i = *(pc++); \ | | | | 1139| 30.1k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 30.1k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1461| 30.1k| } 1462| 30.1k| vmcase(OP_ADD) { ------------------ | | 14| 27.5k|#define vmcase(l) L_##l: ------------------ 1463| 27.5k| op_arith(L, l_addi, luai_numadd); ------------------ | | 961| 27.5k|#define op_arith(L,iop,fop) { \ | | 962| 27.5k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 27.5k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 27.5k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 963| 27.5k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 27.5k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 27.5k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 964| 27.5k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 27.5k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 27.5k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 27.5k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 27.5k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 27.5k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 27.5k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 27.5k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 27.5k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 27.5k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 55.1k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 27.5k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 27.5k, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 27.5k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 27.5k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 27.5k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 18.3k, False: 9.19k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 18.3k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 18.3k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 18.3k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 18.3k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 18.3k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 953| 18.3k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 18.3k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 18.3k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 18.3k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 18.3k| } \ | | | | 955| 27.5k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 9.19k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 9.19k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 9.19k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 18.3k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 9.19k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 9.19k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 9.19k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 1, False: 9.19k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 1|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 1|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 9.19k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 18.3k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 9.19k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 9.19k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 9.19k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 9.19k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 9.19k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 9.19k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 9.19k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 9.19k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 9.19k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 9.19k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 9.19k, False: 1] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 9.19k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 9.19k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 9.19k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 9.19k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 1|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 1|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 1|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 1, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 1|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 1|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 9.19k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 9.19k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 9.19k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 9.19k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 9.19k| }} | | | | ------------------ | | ------------------ ------------------ 1464| 27.5k| vmbreak; ------------------ | | 16| 27.5k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 27.5k|#define vmfetch() { \ | | | | 1134| 27.5k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 27.5k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 27.5k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 27.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 27.5k| i = *(pc++); \ | | | | 1139| 27.5k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 27.5k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1465| 27.5k| } 1466| 128k| vmcase(OP_SUB) { ------------------ | | 14| 128k|#define vmcase(l) L_##l: ------------------ 1467| 128k| op_arith(L, l_subi, luai_numsub); ------------------ | | 961| 128k|#define op_arith(L,iop,fop) { \ | | 962| 128k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 128k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 128k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 963| 128k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 128k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 128k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 964| 128k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 128k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 128k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 128k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 128k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 128k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 128k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 128k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 128k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 128k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 257k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 128k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 101k, False: 27.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 101k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 101k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 101k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 18.4k, False: 82.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 18.4k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 18.4k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 18.4k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 18.4k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 18.4k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 953| 18.4k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 18.4k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 18.4k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 18.4k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 18.4k| } \ | | | | 955| 128k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 110k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 110k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 110k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 220k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 110k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 110k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 110k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 27.5k, False: 82.7k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 27.5k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 27.5k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 110k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 220k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 82.7k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 82.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 82.7k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 82.7k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 82.7k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 82.7k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 110k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 110k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 110k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 110k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 110k, False: 4] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 110k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 110k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 110k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 110k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 4|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 4|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 4|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 4, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 4|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 4|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 110k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 110k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 110k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 110k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 110k| }} | | | | ------------------ | | ------------------ ------------------ 1468| 128k| vmbreak; ------------------ | | 16| 128k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 128k|#define vmfetch() { \ | | | | 1134| 128k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 128k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 128k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 128k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 128k| i = *(pc++); \ | | | | 1139| 128k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 128k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1469| 128k| } 1470| 166k| vmcase(OP_MUL) { ------------------ | | 14| 166k|#define vmcase(l) L_##l: ------------------ 1471| 166k| op_arith(L, l_muli, luai_nummul); ------------------ | | 961| 166k|#define op_arith(L,iop,fop) { \ | | 962| 166k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 166k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 166k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 963| 166k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 166k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 166k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 964| 166k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 166k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 166k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 166k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 166k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 166k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 166k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 166k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 166k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 166k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 333k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 166k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 165k, False: 1.30k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 165k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 165k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 165k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 165k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 165k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 165k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 165k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 165k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 165k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 953| 165k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 165k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 165k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 165k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 165k| } \ | | | | 955| 166k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 1.30k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 1.30k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 1.30k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 2.61k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 1.30k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 1.30k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 1.30k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 1.30k, False: 1] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 1.30k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 1.30k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 1.30k, False: 1] | | | | | | | | ------------------ | | | | | | | | 58| 2.61k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 1|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 1|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 1|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 1] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 1.30k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 1.30k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 1.30k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 1.30k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 1.30k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 1.30k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 1.30k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 1.30k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 1.30k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 1.30k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 1.30k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 1.30k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 1.30k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 1.30k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 1.30k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 1.30k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 1.30k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 1.30k| }} | | | | ------------------ | | ------------------ ------------------ 1472| 166k| vmbreak; ------------------ | | 16| 166k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 166k|#define vmfetch() { \ | | | | 1134| 166k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 166k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 166k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 166k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 166k| i = *(pc++); \ | | | | 1139| 166k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 166k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1473| 166k| } 1474| 166k| vmcase(OP_MOD) { ------------------ | | 14| 91.9k|#define vmcase(l) L_##l: ------------------ 1475| 91.9k| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1107| 91.9k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1100| 91.9k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1476| 91.9k| op_arith(L, luaV_mod, luaV_modf); ------------------ | | 961| 91.9k|#define op_arith(L,iop,fop) { \ | | 962| 91.9k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 91.9k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 91.9k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 963| 91.9k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 91.9k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 91.9k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 964| 91.9k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 91.9k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 91.9k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 91.9k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 91.9k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 91.9k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 91.9k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 91.9k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 91.9k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 91.9k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 183k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 91.9k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 82.7k, False: 9.19k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 82.7k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 82.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 82.7k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 82.7k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 82.7k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 82.7k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 82.7k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 82.7k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 82.7k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 953| 82.7k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 82.7k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 82.7k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 82.7k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 82.7k| } \ | | | | 955| 91.9k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 9.19k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 9.19k| lua_Number n1; lua_Number n2; \ | | | | | | 921| 9.19k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 18.3k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 9.19k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 9.19k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 9.19k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 9.19k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 9.19k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 9.19k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 9.19k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 18.3k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 0|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 9.19k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 9.19k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 9.19k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 9.19k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 9.19k] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 9.19k, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 9.19k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 9.19k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 9.19k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 9.19k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 9.19k, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 9.19k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 9.19k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 9.19k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 9.19k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 9.19k|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 9.19k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 9.19k| }} | | | | ------------------ | | ------------------ ------------------ 1477| 91.9k| vmbreak; ------------------ | | 16| 91.9k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 91.9k|#define vmfetch() { \ | | | | 1134| 91.9k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 91.9k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 91.9k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 91.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 91.9k| i = *(pc++); \ | | | | 1139| 91.9k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 91.9k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1478| 91.9k| } 1479| 91.9k| vmcase(OP_POW) { ------------------ | | 14| 9.16k|#define vmcase(l) L_##l: ------------------ 1480| 9.16k| op_arithf(L, luai_numpow); ------------------ | | 929| 9.16k|#define op_arithf(L,fop) { \ | | 930| 9.16k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 9.16k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 9.16k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 9.16k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 9.16k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 9.16k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 931| 9.16k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 9.16k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 9.16k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 932| 9.16k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 9.16k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 9.16k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 933| 9.16k| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 919| 9.16k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 920| 9.16k| lua_Number n1; lua_Number n2; \ | | | | 921| 9.16k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 18.3k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 9.16k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 9.16k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 9.16k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 0, False: 9.16k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 9.16k, False: 0] | | | | | | ------------------ | | | | | | 58| 18.3k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 9.16k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 9.16k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 9.16k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 9.16k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 9.16k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 9.16k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 9.16k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 9.16k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 9.16k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 9.16k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 13, False: 9.15k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 13|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 13|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 9.16k, False: 0] | | | | | | ------------------ | | | | | | 58| 9.16k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 9.15k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 9.15k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 9.15k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 9.15k, False: 0] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 9.15k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 9.15k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 922| 9.16k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | ------------------ | | | | | | 339| 18.3k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 72| 9.16k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 114| 9.16k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | | | | Branch (339:35): [True: 0, False: 9.16k] | | | | | | ------------------ | | | | ------------------ | | | | 923| 9.16k| }} | | ------------------ ------------------ 1481| 9.16k| vmbreak; ------------------ | | 16| 9.16k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 9.16k|#define vmfetch() { \ | | | | 1134| 9.16k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 9.16k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 9.16k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 9.16k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 9.16k| i = *(pc++); \ | | | | 1139| 9.16k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 9.16k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1482| 9.16k| } 1483| 74.8k| vmcase(OP_DIV) { /* float division (always with floats) */ ------------------ | | 14| 74.8k|#define vmcase(l) L_##l: ------------------ 1484| 74.8k| op_arithf(L, luai_numdiv); ------------------ | | 929| 74.8k|#define op_arithf(L,fop) { \ | | 930| 74.8k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 74.8k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 74.8k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 74.8k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 74.8k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 74.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 931| 74.8k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 74.8k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 74.8k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 932| 74.8k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 74.8k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 74.8k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 933| 74.8k| op_arithf_aux(L, v1, v2, fop); } | | ------------------ | | | | 919| 74.8k|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | 920| 74.8k| lua_Number n1; lua_Number n2; \ | | | | 921| 74.8k| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 149k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 74.8k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 74.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 74.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 8, False: 74.8k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 8|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 8|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 74.8k, False: 2] | | | | | | ------------------ | | | | | | 58| 149k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 74.8k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 74.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 74.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 74.8k, False: 2] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 74.8k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 74.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | ------------------ | | | | | | 57| 74.8k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 327| 74.8k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | ------------------ | | | | | | | | | | 91| 74.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 74.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 0, False: 74.8k] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | ------------------ | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | ------------------ | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (57:2): [True: 74.8k, False: 1] | | | | | | ------------------ | | | | | | 58| 74.8k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 328| 74.8k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | ------------------ | | | | | | | | | | 91| 74.8k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 77| 74.8k|#define rawtt(o) ((o)->tt_) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (91:24): [True: 74.8k, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | ------------------ | | | | | | | | 140| 74.8k|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 74.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 922| 74.8k| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | ------------------ | | | | | | 339| 74.8k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 72| 74.8k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | ------------------ | | | | | | | | 114| 74.8k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 923| 74.8k| }} | | ------------------ ------------------ 1485| 74.8k| vmbreak; ------------------ | | 16| 74.8k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 74.8k|#define vmfetch() { \ | | | | 1134| 74.8k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 74.8k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 74.8k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 74.8k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 74.8k| i = *(pc++); \ | | | | 1139| 74.8k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 74.8k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1486| 74.8k| } 1487| 202k| vmcase(OP_IDIV) { /* floor division */ ------------------ | | 14| 202k|#define vmcase(l) L_##l: ------------------ 1488| 202k| savestate(L, ci); /* in case of division by 0 */ ------------------ | | 1107| 202k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1100| 202k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1489| 202k| op_arith(L, luaV_idiv, luai_numidiv); ------------------ | | 961| 202k|#define op_arith(L,iop,fop) { \ | | 962| 202k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 202k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 202k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 963| 202k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 202k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 202k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 964| 202k| op_arith_aux(L, v1, v2, iop, fop); } | | ------------------ | | | | 949| 202k|#define op_arith_aux(L,v1,v2,iop,fop) { \ | | | | 950| 202k| StkId ra = RA(i); \ | | | | ------------------ | | | | | | 1059| 202k|#define RA(i) (base+GETARG_A(i)) | | | | | | ------------------ | | | | | | | | 125| 202k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | | | ------------------ | | | | | | | | | | 121| 202k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | | | ------------------ | | | | | | | | | | | | 141| 202k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 136| 202k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 951| 202k| if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 202k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 404k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 202k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 202k, False: 8] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | if (ttisinteger(v1) && ttisinteger(v2)) { \ | | | | ------------------ | | | | | | 328| 202k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | ------------------ | | | | | | | | 91| 202k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | ------------------ | | | | | | | | | | 77| 202k|#define rawtt(o) ((o)->tt_) | | | | | | | | ------------------ | | | | | | | | | Branch (91:24): [True: 202k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 952| 202k| lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 202k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 202k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \ | | | | ------------------ | | | | | | 333| 202k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 202k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | 953| 202k| pc++; setivalue(s2v(ra), iop(L, i1, i2)); \ | | | | ------------------ | | | | | | 345| 202k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 72| 202k|#define val_(o) ((o)->value_) | | | | | | ------------------ | | | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | | | ------------------ | | | | | | | | 114| 202k|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | ------------------ | | | | ------------------ | | | | 954| 202k| } \ | | | | 955| 202k| else op_arithf_aux(L, v1, v2, fop); } | | | | ------------------ | | | | | | 919| 8|#define op_arithf_aux(L,v1,v2,fop) { \ | | | | | | 920| 8| lua_Number n1; lua_Number n2; \ | | | | | | 921| 8| if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 16| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 8|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 8|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 8|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 8, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 8|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 8|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 8, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 16| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 0|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \ | | | | | | ------------------ | | | | | | | | 57| 8| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 327| 8|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 8|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 8|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 0, False: 8] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | | | | | | | ------------------ | | | | | | | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | | Branch (57:2): [True: 8, False: 0] | | | | | | | | ------------------ | | | | | | | | 58| 8| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 328| 8|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | | | | | | | ------------------ | | | | | | | | | | | | 91| 8|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | | 77| 8|#define rawtt(o) ((o)->tt_) | | | | | | | | | | | | ------------------ | | | | | | | | | | | | | Branch (91:24): [True: 8, False: 0] | | | | | | | | | | | | ------------------ | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | | | | | | | ------------------ | | | | | | | | | | 140| 8|#define cast_num(i) cast(lua_Number, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 8|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 922| 8| pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \ | | | | | | ------------------ | | | | | | | | 339| 8| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 72| 8|#define val_(o) ((o)->value_) | | | | | | | | ------------------ | | | | | | | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | | | | | | | ------------------ | | | | | | | | | | 114| 8|#define settt_(o,t) ((o)->tt_=(t)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 923| 8| }} | | | | ------------------ | | ------------------ ------------------ 1490| 202k| vmbreak; ------------------ | | 16| 202k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 202k|#define vmfetch() { \ | | | | 1134| 202k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 202k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 202k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 202k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 202k| i = *(pc++); \ | | | | 1139| 202k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 202k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1491| 202k| } 1492| 202k| vmcase(OP_BAND) { ------------------ | | 14| 88.0k|#define vmcase(l) L_##l: ------------------ 1493| 88.0k| op_bitwise(L, l_band); ------------------ | | 993| 88.0k|#define op_bitwise(L,op) { \ | | 994| 88.0k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 88.0k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 88.0k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 88.0k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 88.0k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 88.0k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 995| 88.0k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 88.0k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 88.0k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 996| 88.0k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 88.0k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 88.0k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 997| 88.0k| lua_Integer i1; lua_Integer i2; \ | | 998| 88.0k| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 176k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 687| 88.0k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 675| 88.0k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (675:25): [True: 5.24k, False: 82.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 5.24k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 5.24k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 88.0k, False: 13] | | | | ------------------ | | | | 70| 176k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 82.7k|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 88.0k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 687| 88.0k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 675| 88.0k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (675:25): [True: 51.2k, False: 36.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 51.2k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 51.2k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 88.0k, False: 0] | | | | ------------------ | | | | 70| 88.0k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 36.7k|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 999| 88.0k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 88.0k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 88.0k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 88.0k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 1000| 88.0k| }} ------------------ 1494| 88.0k| vmbreak; ------------------ | | 16| 88.0k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 88.0k|#define vmfetch() { \ | | | | 1134| 88.0k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 88.0k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 88.0k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 88.0k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 88.0k| i = *(pc++); \ | | | | 1139| 88.0k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 88.0k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1495| 88.0k| } 1496| 478k| vmcase(OP_BOR) { ------------------ | | 14| 478k|#define vmcase(l) L_##l: ------------------ 1497| 478k| op_bitwise(L, l_bor); ------------------ | | 993| 478k|#define op_bitwise(L,op) { \ | | 994| 478k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 478k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 478k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 478k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 478k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 478k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 995| 478k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 478k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 478k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 996| 478k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 478k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 478k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 997| 478k| lua_Integer i1; lua_Integer i2; \ | | 998| 478k| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 956k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 687| 478k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 675| 478k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (675:25): [True: 432k, False: 45.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 432k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 432k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 478k, False: 0] | | | | ------------------ | | | | 70| 956k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 45.9k|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 478k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 687| 478k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 675| 478k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (675:25): [True: 432k, False: 45.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 432k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 432k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 478k, False: 0] | | | | ------------------ | | | | 70| 478k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 45.9k|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 999| 478k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 478k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 478k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 478k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 1000| 478k| }} ------------------ 1498| 478k| vmbreak; ------------------ | | 16| 478k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 478k|#define vmfetch() { \ | | | | 1134| 478k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 478k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 478k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 478k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 478k| i = *(pc++); \ | | | | 1139| 478k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 478k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1499| 478k| } 1500| 478k| vmcase(OP_BXOR) { ------------------ | | 14| 10.7k|#define vmcase(l) L_##l: ------------------ 1501| 10.7k| op_bitwise(L, l_bxor); ------------------ | | 993| 10.7k|#define op_bitwise(L,op) { \ | | 994| 10.7k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 10.7k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 10.7k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 10.7k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 10.7k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 10.7k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 995| 10.7k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 10.7k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 10.7k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 996| 10.7k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 10.7k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 10.7k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 997| 10.7k| lua_Integer i1; lua_Integer i2; \ | | 998| 10.7k| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 21.4k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 687| 10.7k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 675| 10.7k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (675:25): [True: 10.6k, False: 122] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 10.6k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 10.6k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 10.7k, False: 0] | | | | ------------------ | | | | 70| 21.4k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 122|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 10.7k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 687| 10.7k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 675| 10.7k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (675:25): [True: 10.7k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 10.7k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 10.7k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 10.7k, False: 0] | | | | ------------------ | | | | 70| 10.7k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 999| 10.7k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 10.7k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 10.7k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 10.7k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 1000| 10.7k| }} ------------------ 1502| 10.7k| vmbreak; ------------------ | | 16| 10.7k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 10.7k|#define vmfetch() { \ | | | | 1134| 10.7k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 10.7k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 10.7k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 10.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 10.7k| i = *(pc++); \ | | | | 1139| 10.7k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 10.7k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1503| 10.7k| } 1504| 45.9k| vmcase(OP_SHR) { ------------------ | | 14| 45.9k|#define vmcase(l) L_##l: ------------------ 1505| 45.9k| op_bitwise(L, luaV_shiftr); ------------------ | | 993| 45.9k|#define op_bitwise(L,op) { \ | | 994| 45.9k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 45.9k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 45.9k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 45.9k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 45.9k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 45.9k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 995| 45.9k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 45.9k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 45.9k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 996| 45.9k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 45.9k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 45.9k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 997| 45.9k| lua_Integer i1; lua_Integer i2; \ | | 998| 45.9k| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 91.9k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 687| 45.9k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 675| 45.9k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (675:25): [True: 45.9k, False: 1] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 45.9k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 45.9k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 45.9k, False: 0] | | | | ------------------ | | | | 70| 91.9k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 1|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 45.9k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 687| 45.9k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 675| 45.9k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (675:25): [True: 45.9k, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 45.9k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 45.9k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 45.9k, False: 0] | | | | ------------------ | | | | 70| 45.9k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 0|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 999| 45.9k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 45.9k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 45.9k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 45.9k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 1000| 45.9k| }} ------------------ 1506| 45.9k| vmbreak; ------------------ | | 16| 45.9k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 45.9k|#define vmfetch() { \ | | | | 1134| 45.9k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 45.9k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 45.9k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 45.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 45.9k| i = *(pc++); \ | | | | 1139| 45.9k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 45.9k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1507| 45.9k| } 1508| 52.5k| vmcase(OP_SHL) { ------------------ | | 14| 52.5k|#define vmcase(l) L_##l: ------------------ 1509| 52.5k| op_bitwise(L, luaV_shiftl); ------------------ | | 993| 52.5k|#define op_bitwise(L,op) { \ | | 994| 52.5k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 52.5k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 52.5k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 52.5k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 52.5k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 52.5k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 995| 52.5k| TValue *v1 = vRB(i); \ | | ------------------ | | | | 1061| 52.5k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 52.5k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 996| 52.5k| TValue *v2 = vRC(i); \ | | ------------------ | | | | 1064| 52.5k|#define vRC(i) s2v(RC(i)) | | | | ------------------ | | | | | | 172| 52.5k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 997| 52.5k| lua_Integer i1; lua_Integer i2; \ | | 998| 52.5k| if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 105k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 687| 52.5k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 675| 52.5k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (675:25): [True: 28.8k, False: 23.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 28.8k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 28.8k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 52.5k, False: 0] | | | | ------------------ | | | | 70| 105k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 23.7k|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \ | | ------------------ | | | | 69| 52.5k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 687| 52.5k|#define l_likely(x) luai_likely(x) | | | | | | ------------------ | | | | | | | | 675| 52.5k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | | | ------------------ | | | | | | | | | Branch (675:25): [True: 38.1k, False: 14.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | | | ------------------ | | | | | | 333| 38.1k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | | | ------------------ | | | | | | | | 115| 38.1k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (69:3): [True: 52.5k, False: 0] | | | | ------------------ | | | | 70| 52.5k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | | | ------------------ | | | | | | 36| 14.3k|#define LUA_FLOORN2I F2Ieq | | | | ------------------ | | ------------------ | | 999| 52.5k| pc++; setivalue(s2v(ra), op(i1, i2)); \ | | ------------------ | | | | 345| 52.5k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 72| 52.5k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | | | ------------------ | | | | | | 114| 52.5k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | ------------------ | | 1000| 52.5k| }} ------------------ 1510| 52.5k| vmbreak; ------------------ | | 16| 52.5k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 52.5k|#define vmfetch() { \ | | | | 1134| 52.5k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 52.5k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 52.5k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 52.5k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 52.5k| i = *(pc++); \ | | | | 1139| 52.5k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 52.5k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1511| 52.5k| } 1512| 52.5k| vmcase(OP_MMBIN) { ------------------ | | 14| 17|#define vmcase(l) L_##l: ------------------ 1513| 17| StkId ra = RA(i); ------------------ | | 1059| 17|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 17|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 17|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 17|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 17|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1514| 17| Instruction pi = *(pc - 2); /* original arith. expression */ 1515| 17| TValue *rb = vRB(i); ------------------ | | 1061| 17|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 17|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1516| 17| TMS tm = (TMS)GETARG_C(i); ------------------ | | 132| 17|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 17|#define check_exp(c,e) (e) | | ------------------ ------------------ 1517| 17| StkId result = RA(pi); ------------------ | | 1059| 17|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 17|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 17|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 17|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 17|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1518| 17| lua_assert(OP_ADD <= GET_OPCODE(pi) && GET_OPCODE(pi) <= OP_SHR); ------------------ | | 114| 17|#define lua_assert(c) ((void)0) ------------------ 1519| 17| Protect(luaT_trybinTM(L, s2v(ra), rb, result, tm)); ------------------ | | 1114| 17|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 17|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 17|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 17|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1520| 17| vmbreak; ------------------ | | 16| 17|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 17|#define vmfetch() { \ | | | | 1134| 17| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 17|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 17|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 17] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 17| i = *(pc++); \ | | | | 1139| 17|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 17|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1521| 17| } 1522| 17| vmcase(OP_MMBINI) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1523| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1524| 0| Instruction pi = *(pc - 2); /* original arith. expression */ 1525| 0| int imm = GETARG_sB(i); ------------------ | | 129| 0|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | ------------------ | | | | 101| 0|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 0|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 0|#define MAXARG_C ((1<>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1529| 0| Protect(luaT_trybiniTM(L, s2v(ra), imm, flip, result, tm)); ------------------ | | 1114| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1530| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1531| 0| } 1532| 0| vmcase(OP_MMBINK) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1533| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1534| 0| Instruction pi = *(pc - 2); /* original arith. expression */ 1535| 0| TValue *imm = KB(i); ------------------ | | 1062| 0|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 0|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1536| 0| TMS tm = (TMS)GETARG_C(i); ------------------ | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1537| 0| int flip = GETARG_k(i); ------------------ | | 137| 0|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1538| 0| StkId result = RA(pi); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1539| 0| Protect(luaT_trybinassocTM(L, s2v(ra), imm, flip, result, tm)); ------------------ | | 1114| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1540| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1541| 0| } 1542| 553k| vmcase(OP_UNM) { ------------------ | | 14| 553k|#define vmcase(l) L_##l: ------------------ 1543| 553k| StkId ra = RA(i); ------------------ | | 1059| 553k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 553k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 553k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 553k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 553k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1544| 553k| TValue *rb = vRB(i); ------------------ | | 1061| 553k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 553k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1545| 553k| lua_Number nb; 1546| 553k| if (ttisinteger(rb)) { ------------------ | | 328| 553k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 553k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 553k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 148k, False: 405k] | | | | ------------------ | | ------------------ ------------------ 1547| 148k| lua_Integer ib = ivalue(rb); ------------------ | | 333| 148k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 148k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1548| 148k| setivalue(s2v(ra), intop(-, 0, ib)); ------------------ | | 345| 148k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 148k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 148k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1549| 148k| } 1550| 405k| else if (tonumberns(rb, nb)) { ------------------ | | 57| 405k| (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 327| 405k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 405k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 405k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 405k, False: 4] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? ((n) = fltvalue(o), 1) : \ | | ------------------ | | | | 332| 405k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 405k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (57:2): [True: 405k, False: 4] | | ------------------ | | 58| 405k| (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 328| 4|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 4|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 4|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 4] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0)) | | ------------------ | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1551| 405k| setfltvalue(s2v(ra), luai_numunm(L, nb)); ------------------ | | 339| 405k| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 405k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 405k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1552| 405k| } 1553| 4| else 1554| 4| Protect(luaT_trybinTM(L, rb, rb, ra, TM_UNM)); ------------------ | | 1114| 4|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 4|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 4|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 4|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1555| 553k| vmbreak; ------------------ | | 16| 553k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 553k|#define vmfetch() { \ | | | | 1134| 553k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 553k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 553k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 553k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 553k| i = *(pc++); \ | | | | 1139| 553k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 553k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1556| 553k| } 1557| 764k| vmcase(OP_BNOT) { ------------------ | | 14| 764k|#define vmcase(l) L_##l: ------------------ 1558| 764k| StkId ra = RA(i); ------------------ | | 1059| 764k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 764k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 764k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 764k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 764k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1559| 764k| TValue *rb = vRB(i); ------------------ | | 1061| 764k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 764k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1560| 764k| lua_Integer ib; 1561| 764k| if (tointegerns(rb, &ib)) { ------------------ | | 69| 764k| (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 687| 764k|#define l_likely(x) luai_likely(x) | | | | ------------------ | | | | | | 675| 764k|#define luai_likely(x) (__builtin_expect(((x) != 0), 1)) | | | | | | ------------------ | | | | | | | Branch (675:25): [True: 433k, False: 331k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (l_likely(ttisinteger(o)) ? (*(i) = ivalue(o), 1) \ | | ------------------ | | | | 333| 433k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 433k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | | Branch (69:3): [True: 764k, False: 7] | | ------------------ | | 70| 764k| : luaV_tointegerns(o,i,LUA_FLOORN2I)) | | ------------------ | | | | 36| 331k|#define LUA_FLOORN2I F2Ieq | | ------------------ ------------------ 1562| 764k| setivalue(s2v(ra), intop(^, ~l_castS2U(0), ib)); ------------------ | | 345| 764k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 764k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 764k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1563| 764k| } 1564| 7| else 1565| 7| Protect(luaT_trybinTM(L, rb, rb, ra, TM_BNOT)); ------------------ | | 1114| 7|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 7|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 7|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 7|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1566| 764k| vmbreak; ------------------ | | 16| 764k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 764k|#define vmfetch() { \ | | | | 1134| 764k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 764k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 764k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 764k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 764k| i = *(pc++); \ | | | | 1139| 764k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 764k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1567| 764k| } 1568| 764k| vmcase(OP_NOT) { ------------------ | | 14| 24.8k|#define vmcase(l) L_##l: ------------------ 1569| 24.8k| StkId ra = RA(i); ------------------ | | 1059| 24.8k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 24.8k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 24.8k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 24.8k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 24.8k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1570| 24.8k| TValue *rb = vRB(i); ------------------ | | 1061| 24.8k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 24.8k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1571| 24.8k| if (l_isfalse(rb)) ------------------ | | 247| 24.8k|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 24.8k|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 49.7k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 24.8k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 24.8k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 193| 24.8k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 24.8k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 24.8k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 24.8k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 9.20k, False: 15.6k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1572| 24.8k| setbtvalue(s2v(ra)); ------------------ | | 251| 9.20k|#define setbtvalue(obj) settt_(obj, LUA_VTRUE) | | ------------------ | | | | 114| 9.20k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1573| 15.6k| else 1574| 24.8k| setbfvalue(s2v(ra)); ------------------ | | 250| 15.6k|#define setbfvalue(obj) settt_(obj, LUA_VFALSE) | | ------------------ | | | | 114| 15.6k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1575| 24.8k| vmbreak; ------------------ | | 16| 24.8k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 24.8k|#define vmfetch() { \ | | | | 1134| 24.8k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 24.8k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 24.8k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 24.8k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 24.8k| i = *(pc++); \ | | | | 1139| 24.8k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 24.8k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1576| 24.8k| } 1577| 506k| vmcase(OP_LEN) { ------------------ | | 14| 506k|#define vmcase(l) L_##l: ------------------ 1578| 506k| StkId ra = RA(i); ------------------ | | 1059| 506k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 506k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 506k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 506k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 506k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1579| 506k| Protect(luaV_objlen(L, ra, vRB(i))); ------------------ | | 1114| 506k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 506k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 506k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 506k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1580| 506k| vmbreak; ------------------ | | 16| 506k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 506k|#define vmfetch() { \ | | | | 1134| 506k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 506k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 506k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 506k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 506k| i = *(pc++); \ | | | | 1139| 506k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 506k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1581| 506k| } 1582| 506k| vmcase(OP_CONCAT) { ------------------ | | 14| 83.3k|#define vmcase(l) L_##l: ------------------ 1583| 83.3k| StkId ra = RA(i); ------------------ | | 1059| 83.3k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 83.3k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 83.3k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 83.3k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 83.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1584| 83.3k| int n = GETARG_B(i); /* number of elements to concatenate */ ------------------ | | 128| 83.3k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 83.3k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1585| 83.3k| L->top.p = ra + n; /* mark the end of concat operands */ 1586| 83.3k| ProtectNT(luaV_concat(L, n)); ------------------ | | 1117| 83.3k|#define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1100| 83.3k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ | | #define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 83.3k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1587| 83.3k| checkGC(L, L->top.p); /* 'luaV_concat' ensures correct top */ ------------------ | | 1127| 83.3k| { luaC_condGC(L, (savepc(L), L->top.p = (c)), \ | | ------------------ | | | | 168| 83.3k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 83.3k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 26, False: 83.2k] | | | | ------------------ | | | | 169| 83.3k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 83.3k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 1128| 83.3k| updatetrap(ci)); \ | | 1129| 83.3k| luai_threadyield(L); } | | ------------------ | | | | 273| 83.3k|#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 265| 83.3k|#define lua_unlock(L) ((void) 0) | | | | ------------------ | | | | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 264| 83.3k|#define lua_lock(L) ((void) 0) | | | | ------------------ | | ------------------ ------------------ 1588| 83.3k| vmbreak; ------------------ | | 16| 83.3k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 83.3k|#define vmfetch() { \ | | | | 1134| 83.3k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 83.3k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 83.3k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 83.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 83.3k| i = *(pc++); \ | | | | 1139| 83.3k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 83.3k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1589| 83.3k| } 1590| 83.3k| vmcase(OP_CLOSE) { ------------------ | | 14| 9.20k|#define vmcase(l) L_##l: ------------------ 1591| 9.20k| StkId ra = RA(i); ------------------ | | 1059| 9.20k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 9.20k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 9.20k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 9.20k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 9.20k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1592| 9.20k| Protect(luaF_close(L, ra, LUA_OK, 1)); ------------------ | | 1114| 9.20k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 9.20k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 9.20k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 9.20k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1593| 9.20k| vmbreak; ------------------ | | 16| 9.20k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 9.20k|#define vmfetch() { \ | | | | 1134| 9.20k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 9.20k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 9.20k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 9.20k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 9.20k| i = *(pc++); \ | | | | 1139| 9.20k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 9.20k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1594| 9.20k| } 1595| 14.3k| vmcase(OP_TBC) { ------------------ | | 14| 14.3k|#define vmcase(l) L_##l: ------------------ 1596| 14.3k| StkId ra = RA(i); ------------------ | | 1059| 14.3k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 14.3k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 14.3k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 14.3k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 14.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1597| | /* create new to-be-closed upvalue */ 1598| 14.3k| halfProtect(luaF_newtbcupval(L, ra)); ------------------ | | 1123| 14.3k|#define halfProtect(exp) (savestate(L,ci), (exp)) | | ------------------ | | | | 1107| 14.3k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 14.3k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ ------------------ 1599| 14.3k| vmbreak; ------------------ | | 16| 14.3k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 14.3k|#define vmfetch() { \ | | | | 1134| 14.3k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 14.3k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 14.3k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 14.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 14.3k| i = *(pc++); \ | | | | 1139| 14.3k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 14.3k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1600| 14.3k| } 1601| 306k| vmcase(OP_JMP) { ------------------ | | 14| 306k|#define vmcase(l) L_##l: ------------------ 1602| 306k| dojump(ci, i, 0); ------------------ | | 1083| 306k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | ------------------ | | | | 151| 306k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | ------------------ | | | | | | 115| 306k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | ------------------ | | | | 1070| 306k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1603| 306k| vmbreak; ------------------ | | 16| 306k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 306k|#define vmfetch() { \ | | | | 1134| 306k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 306k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 306k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 306k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 306k| i = *(pc++); \ | | | | 1139| 306k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 306k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1604| 306k| } 1605| 306k| vmcase(OP_EQ) { ------------------ | | 14| 82.7k|#define vmcase(l) L_##l: ------------------ 1606| 82.7k| StkId ra = RA(i); ------------------ | | 1059| 82.7k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 82.7k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 82.7k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 82.7k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 82.7k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1607| 82.7k| int cond; 1608| 82.7k| TValue *rb = vRB(i); ------------------ | | 1061| 82.7k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 82.7k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1609| 82.7k| Protect(cond = luaV_equalobj(L, s2v(ra), rb)); ------------------ | | 1114| 82.7k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 82.7k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 82.7k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 82.7k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1610| 82.7k| docondjump(); ------------------ | | 1094| 82.7k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 82.7k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 115| 82.7k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1087| 9.19k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1083| 9.19k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 9.19k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 115| 9.19k|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1070| 9.19k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1094:26): [True: 73.5k, False: 9.19k] | | ------------------ ------------------ 1611| 82.7k| vmbreak; ------------------ | | 16| 82.7k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 82.7k|#define vmfetch() { \ | | | | 1134| 82.7k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 82.7k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 82.7k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 82.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 82.7k| i = *(pc++); \ | | | | 1139| 82.7k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 82.7k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1612| 82.7k| } 1613| 82.7k| vmcase(OP_LT) { ------------------ | | 14| 30|#define vmcase(l) L_##l: ------------------ 1614| 30| op_order(L, l_lti, LTnum, lessthanothers); ------------------ | | 1008| 30|#define op_order(L,opi,opn,other) { \ | | 1009| 30| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 30|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 30|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 30|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 30|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 30|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1010| 30| int cond; \ | | 1011| 30| TValue *rb = vRB(i); \ | | ------------------ | | | | 1061| 30|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 30|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 1012| 30| if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 328| 30|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 60|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 30|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 13, False: 17] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 328| 13|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 13|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 13|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 13, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1013| 13| lua_Integer ia = ivalue(s2v(ra)); \ | | ------------------ | | | | 333| 13|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 13|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1014| 13| lua_Integer ib = ivalue(rb); \ | | ------------------ | | | | 333| 13|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 13|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1015| 13| cond = opi(ia, ib); \ | | ------------------ | | | | 1614| 13| op_order(L, l_lti, LTnum, lessthanothers); | | | | ------------------ | | | | | | 890| 13|#define l_lti(a,b) (a < b) | | | | ------------------ | | ------------------ | | 1016| 13| } \ | | 1017| 30| else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 326| 17|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 34|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 17|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 17|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 17] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 326| 0|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1018| 17| cond = opn(s2v(ra), rb); \ | | ------------------ | | | | 172| 0|#define s2v(o) (&(o)->val) | | ------------------ | | 1019| 17| else \ | | 1020| 17| Protect(cond = other(L, s2v(ra), rb)); \ | | ------------------ | | | | 1114| 17|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1107| 17|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1100| 17|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1070| 17|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1021| 30| docondjump(); } | | ------------------ | | | | 1094| 30|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 30|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 115| 30|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1087| 30|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1083| 30|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 30| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 30|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1070| 30|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1094:26): [True: 0, False: 30] | | | | ------------------ | | ------------------ ------------------ 1615| 30| vmbreak; ------------------ | | 16| 30|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 30|#define vmfetch() { \ | | | | 1134| 30| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 30|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 30|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 30] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 30| i = *(pc++); \ | | | | 1139| 30|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 30|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1616| 30| } 1617| 143k| vmcase(OP_LE) { ------------------ | | 14| 143k|#define vmcase(l) L_##l: ------------------ 1618| 143k| op_order(L, l_lei, LEnum, lessequalothers); ------------------ | | 1008| 143k|#define op_order(L,opi,opn,other) { \ | | 1009| 143k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 143k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 143k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 143k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 143k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 143k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1010| 143k| int cond; \ | | 1011| 143k| TValue *rb = vRB(i); \ | | ------------------ | | | | 1061| 143k|#define vRB(i) s2v(RB(i)) | | | | ------------------ | | | | | | 172| 143k|#define s2v(o) (&(o)->val) | | | | ------------------ | | ------------------ | | 1012| 143k| if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 328| 143k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 286k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 143k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 143k, False: 4] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \ | | ------------------ | | | | 328| 143k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | | | ------------------ | | | | | | 91| 143k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 143k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 143k, False: 26] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1013| 143k| lua_Integer ia = ivalue(s2v(ra)); \ | | ------------------ | | | | 333| 143k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 143k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1014| 143k| lua_Integer ib = ivalue(rb); \ | | ------------------ | | | | 333| 143k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | | | ------------------ | | | | | | 115| 143k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1015| 143k| cond = opi(ia, ib); \ | | ------------------ | | | | 1618| 143k| op_order(L, l_lei, LEnum, lessequalothers); | | | | ------------------ | | | | | | 891| 143k|#define l_lei(a,b) (a <= b) | | | | ------------------ | | ------------------ | | 1016| 143k| } \ | | 1017| 143k| else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 326| 30|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 60|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 30|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 30|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 26, False: 4] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \ | | ------------------ | | | | 326| 26|#define ttisnumber(o) checktype((o), LUA_TNUMBER) | | | | ------------------ | | | | | | 92| 26|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 26|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 26|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 26, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1018| 30| cond = opn(s2v(ra), rb); \ | | ------------------ | | | | 172| 26|#define s2v(o) (&(o)->val) | | ------------------ | | 1019| 30| else \ | | 1020| 30| Protect(cond = other(L, s2v(ra), rb)); \ | | ------------------ | | | | 1114| 4|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1107| 4|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1100| 4|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1070| 4|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1021| 143k| docondjump(); } | | ------------------ | | | | 1094| 143k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 143k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 115| 143k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1087| 137k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1083| 137k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 137k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 137k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1070| 137k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1094:26): [True: 5.29k, False: 137k] | | | | ------------------ | | ------------------ ------------------ 1619| 143k| vmbreak; ------------------ | | 16| 143k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 143k|#define vmfetch() { \ | | | | 1134| 143k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 143k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 143k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 143k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 143k| i = *(pc++); \ | | | | 1139| 143k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 143k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1620| 143k| } 1621| 143k| vmcase(OP_EQK) { ------------------ | | 14| 11.7k|#define vmcase(l) L_##l: ------------------ 1622| 11.7k| StkId ra = RA(i); ------------------ | | 1059| 11.7k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 11.7k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 11.7k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 11.7k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 11.7k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1623| 11.7k| TValue *rb = KB(i); ------------------ | | 1062| 11.7k|#define KB(i) (k+GETARG_B(i)) | | ------------------ | | | | 128| 11.7k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | | | ------------------ | | | | | | 115| 11.7k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ 1624| | /* basic types do not use '__eq'; we can use raw equality */ 1625| 11.7k| int cond = luaV_rawequalobj(s2v(ra), rb); ------------------ | | 75| 11.7k|#define luaV_rawequalobj(t1,t2) luaV_equalobj(NULL,t1,t2) ------------------ 1626| 11.7k| docondjump(); ------------------ | | 1094| 11.7k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 11.7k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 115| 11.7k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1087| 11.7k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1083| 11.7k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 11.7k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 115| 11.7k|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1070| 11.7k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1094:26): [True: 0, False: 11.7k] | | ------------------ ------------------ 1627| 11.7k| vmbreak; ------------------ | | 16| 11.7k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 11.7k|#define vmfetch() { \ | | | | 1134| 11.7k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 11.7k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 11.7k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 11.7k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 11.7k| i = *(pc++); \ | | | | 1139| 11.7k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 11.7k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1628| 11.7k| } 1629| 11.7k| vmcase(OP_EQI) { ------------------ | | 14| 2|#define vmcase(l) L_##l: ------------------ 1630| 2| StkId ra = RA(i); ------------------ | | 1059| 2|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 2|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 2|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 2|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 2|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1631| 2| int cond; 1632| 2| int im = GETARG_sB(i); ------------------ | | 129| 2|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | ------------------ | | | | 101| 2|#define sC2int(i) ((i) - OFFSET_sC) | | | | ------------------ | | | | | | 98| 2|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | ------------------ | | | | | | | | 97| 2|#define MAXARG_C ((1<tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 2, False: 0] | | | | ------------------ | | ------------------ ------------------ 1634| 2| cond = (ivalue(s2v(ra)) == im); ------------------ | | 333| 2|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 2|#define check_exp(c,e) (e) | | ------------------ ------------------ 1635| 0| else if (ttisfloat(s2v(ra))) ------------------ | | 327| 0|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 1636| 0| cond = luai_numeq(fltvalue(s2v(ra)), cast_num(im)); ------------------ | | 350| 0|#define luai_numeq(a,b) ((a)==(b)) ------------------ 1637| 0| else 1638| 0| cond = 0; /* other types cannot be equal to a number */ 1639| 2| docondjump(); ------------------ | | 1094| 2|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 2|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 115| 2|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1087| 2|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1083| 2|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 2| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 115| 2|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1070| 2|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1094:26): [True: 0, False: 2] | | ------------------ ------------------ 1640| 2| vmbreak; ------------------ | | 16| 2|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 2|#define vmfetch() { \ | | | | 1134| 2| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 2|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 2|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 2] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 2| i = *(pc++); \ | | | | 1139| 2|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 2|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1641| 2| } 1642| 165k| vmcase(OP_LTI) { ------------------ | | 14| 165k|#define vmcase(l) L_##l: ------------------ 1643| 165k| op_orderI(L, l_lti, luai_numlt, 0, TM_LT); ------------------ | | 1028| 165k|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1029| 165k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 165k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 165k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 165k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 165k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 165k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1030| 165k| int cond; \ | | 1031| 165k| int im = GETARG_sB(i); \ | | ------------------ | | | | 129| 165k|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | | | ------------------ | | | | | | 101| 165k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 165k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 165k|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 165k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1033| 165k| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1643| 165k| op_orderI(L, l_lti, luai_numlt, 0, TM_LT); | | | | ------------------ | | | | | | 890| 165k|#define l_lti(a,b) (a < b) | | | | ------------------ | | ------------------ | | 1034| 165k| else if (ttisfloat(s2v(ra))) { \ | | ------------------ | | | | 327| 0|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 0| lua_Number fa = fltvalue(s2v(ra)); \ | | ------------------ | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1036| 0| lua_Number fim = cast_num(im); \ | | ------------------ | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 1037| 0| cond = opf(fa, fim); \ | | ------------------ | | | | 1643| 0| op_orderI(L, l_lti, luai_numlt, 0, TM_LT); | | | | ------------------ | | | | | | 351| 0|#define luai_numlt(a,b) ((a)<(b)) | | | | ------------------ | | ------------------ | | 1038| 0| } \ | | 1039| 0| else { \ | | 1040| 0| int isf = GETARG_C(i); \ | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1041| 0| Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \ | | ------------------ | | | | 1114| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1042| 0| } \ | | 1043| 165k| docondjump(); } | | ------------------ | | | | 1094| 165k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 165k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 115| 165k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1087| 82.7k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1083| 82.7k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 82.7k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 82.7k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1070| 82.7k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1094:26): [True: 82.7k, False: 82.7k] | | | | ------------------ | | ------------------ ------------------ 1644| 165k| vmbreak; ------------------ | | 16| 165k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 165k|#define vmfetch() { \ | | | | 1134| 165k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 165k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 165k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 165k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 165k| i = *(pc++); \ | | | | 1139| 165k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 165k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1645| 165k| } 1646| 165k| vmcase(OP_LEI) { ------------------ | | 14| 18.3k|#define vmcase(l) L_##l: ------------------ 1647| 18.3k| op_orderI(L, l_lei, luai_numle, 0, TM_LE); ------------------ | | 1028| 18.3k|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1029| 18.3k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 18.3k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 18.3k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 18.3k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 18.3k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 18.3k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1030| 18.3k| int cond; \ | | 1031| 18.3k| int im = GETARG_sB(i); \ | | ------------------ | | | | 129| 18.3k|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | | | ------------------ | | | | | | 101| 18.3k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 18.3k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 18.3k|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 18.3k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1033| 18.3k| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1647| 18.3k| op_orderI(L, l_lei, luai_numle, 0, TM_LE); | | | | ------------------ | | | | | | 891| 18.3k|#define l_lei(a,b) (a <= b) | | | | ------------------ | | ------------------ | | 1034| 18.3k| else if (ttisfloat(s2v(ra))) { \ | | ------------------ | | | | 327| 0|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 0| lua_Number fa = fltvalue(s2v(ra)); \ | | ------------------ | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1036| 0| lua_Number fim = cast_num(im); \ | | ------------------ | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 1037| 0| cond = opf(fa, fim); \ | | ------------------ | | | | 1647| 0| op_orderI(L, l_lei, luai_numle, 0, TM_LE); | | | | ------------------ | | | | | | 352| 0|#define luai_numle(a,b) ((a)<=(b)) | | | | ------------------ | | ------------------ | | 1038| 0| } \ | | 1039| 0| else { \ | | 1040| 0| int isf = GETARG_C(i); \ | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1041| 0| Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \ | | ------------------ | | | | 1114| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1042| 0| } \ | | 1043| 18.3k| docondjump(); } | | ------------------ | | | | 1094| 18.3k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 18.3k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 115| 18.3k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1087| 18.3k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1083| 18.3k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 18.3k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 18.3k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1070| 18.3k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1094:26): [True: 0, False: 18.3k] | | | | ------------------ | | ------------------ ------------------ 1648| 18.3k| vmbreak; ------------------ | | 16| 18.3k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 18.3k|#define vmfetch() { \ | | | | 1134| 18.3k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 18.3k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 18.3k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 18.3k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 18.3k| i = *(pc++); \ | | | | 1139| 18.3k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 18.3k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1649| 18.3k| } 1650| 229k| vmcase(OP_GTI) { ------------------ | | 14| 229k|#define vmcase(l) L_##l: ------------------ 1651| 229k| op_orderI(L, l_gti, luai_numgt, 1, TM_LT); ------------------ | | 1028| 229k|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1029| 229k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 229k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 229k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 229k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 229k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 229k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1030| 229k| int cond; \ | | 1031| 229k| int im = GETARG_sB(i); \ | | ------------------ | | | | 129| 229k|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | | | ------------------ | | | | | | 101| 229k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 229k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 229k|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 220k, False: 9.19k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1033| 229k| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1651| 220k| op_orderI(L, l_gti, luai_numgt, 1, TM_LT); | | | | ------------------ | | | | | | 892| 220k|#define l_gti(a,b) (a > b) | | | | ------------------ | | ------------------ | | 1034| 229k| else if (ttisfloat(s2v(ra))) { \ | | ------------------ | | | | 327| 9.19k|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 9.19k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 9.19k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 9.19k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 9.19k| lua_Number fa = fltvalue(s2v(ra)); \ | | ------------------ | | | | 332| 9.19k|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 9.19k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1036| 9.19k| lua_Number fim = cast_num(im); \ | | ------------------ | | | | 140| 9.19k|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 9.19k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 1037| 9.19k| cond = opf(fa, fim); \ | | ------------------ | | | | 1651| 9.19k| op_orderI(L, l_gti, luai_numgt, 1, TM_LT); | | | | ------------------ | | | | | | 353| 9.19k|#define luai_numgt(a,b) ((a)>(b)) | | | | ------------------ | | ------------------ | | 1038| 9.19k| } \ | | 1039| 9.19k| else { \ | | 1040| 0| int isf = GETARG_C(i); \ | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1041| 0| Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \ | | ------------------ | | | | 1114| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1042| 0| } \ | | 1043| 229k| docondjump(); } | | ------------------ | | | | 1094| 229k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 229k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 115| 229k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1087| 9.20k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1083| 9.20k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 9.20k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 9.20k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1070| 9.20k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1094:26): [True: 220k, False: 9.20k] | | | | ------------------ | | ------------------ ------------------ 1652| 229k| vmbreak; ------------------ | | 16| 229k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 229k|#define vmfetch() { \ | | | | 1134| 229k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 229k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 229k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 229k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 229k| i = *(pc++); \ | | | | 1139| 229k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 229k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1653| 229k| } 1654| 229k| vmcase(OP_GEI) { ------------------ | | 14| 143k|#define vmcase(l) L_##l: ------------------ 1655| 143k| op_orderI(L, l_gei, luai_numge, 1, TM_LE); ------------------ | | 1028| 143k|#define op_orderI(L,opi,opf,inv,tm) { \ | | 1029| 143k| StkId ra = RA(i); \ | | ------------------ | | | | 1059| 143k|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 143k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 143k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 143k|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 143k|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1030| 143k| int cond; \ | | 1031| 143k| int im = GETARG_sB(i); \ | | ------------------ | | | | 129| 143k|#define GETARG_sB(i) sC2int(GETARG_B(i)) | | | | ------------------ | | | | | | 101| 143k|#define sC2int(i) ((i) - OFFSET_sC) | | | | | | ------------------ | | | | | | | | 98| 143k|#define OFFSET_sC (MAXARG_C >> 1) | | | | | | | | ------------------ | | | | | | | | | | 97| 143k|#define MAXARG_C ((1<tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 143k, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1033| 143k| cond = opi(ivalue(s2v(ra)), im); \ | | ------------------ | | | | 1655| 143k| op_orderI(L, l_gei, luai_numge, 1, TM_LE); | | | | ------------------ | | | | | | 893| 143k|#define l_gei(a,b) (a >= b) | | | | ------------------ | | ------------------ | | 1034| 143k| else if (ttisfloat(s2v(ra))) { \ | | ------------------ | | | | 327| 0|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1035| 0| lua_Number fa = fltvalue(s2v(ra)); \ | | ------------------ | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1036| 0| lua_Number fim = cast_num(im); \ | | ------------------ | | | | 140| 0|#define cast_num(i) cast(lua_Number, (i)) | | | | ------------------ | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ | | 1037| 0| cond = opf(fa, fim); \ | | ------------------ | | | | 1655| 0| op_orderI(L, l_gei, luai_numge, 1, TM_LE); | | | | ------------------ | | | | | | 354| 0|#define luai_numge(a,b) ((a)>=(b)) | | | | ------------------ | | ------------------ | | 1038| 0| } \ | | 1039| 0| else { \ | | 1040| 0| int isf = GETARG_C(i); \ | | ------------------ | | | | 132| 0|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | 1041| 0| Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \ | | ------------------ | | | | 1114| 0|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | | | ------------------ | | | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | | | ------------------ | | | | ------------------ | | | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | | | ------------------ | | | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ | | 1042| 0| } \ | | 1043| 143k| docondjump(); } | | ------------------ | | | | 1094| 143k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 137| 143k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | | | ------------------ | | | | | | | | 115| 143k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | | | ------------------ | | | | | | 1087| 135k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | | | ------------------ | | | | | | | | 1083| 135k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 151| 135k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | | | ------------------ | | | | | | | | | | | | 115| 135k|#define check_exp(c,e) (e) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | | | ------------------ | | | | | | | | | | 1070| 135k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | | Branch (1094:26): [True: 7.84k, False: 135k] | | | | ------------------ | | ------------------ ------------------ 1656| 143k| vmbreak; ------------------ | | 16| 143k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 143k|#define vmfetch() { \ | | | | 1134| 143k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 143k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 143k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 143k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 143k| i = *(pc++); \ | | | | 1139| 143k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 143k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1657| 143k| } 1658| 243k| vmcase(OP_TEST) { ------------------ | | 14| 243k|#define vmcase(l) L_##l: ------------------ 1659| 243k| StkId ra = RA(i); ------------------ | | 1059| 243k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 243k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 243k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 243k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 243k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1660| 243k| int cond = !l_isfalse(s2v(ra)); ------------------ | | 247| 243k|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 243k|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 486k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 243k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 243k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 193| 243k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 243k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 243k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 243k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 10.4k, False: 232k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1661| 243k| docondjump(); ------------------ | | 1094| 243k|#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 137| 243k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | | | ------------------ | | | | | | 115| 243k|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci); | | ------------------ | | | | 1087| 136k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | | | ------------------ | | | | | | 1083| 136k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 151| 136k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | | | ------------------ | | | | | | | | | | 115| 136k|#define check_exp(c,e) (e) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | | | ------------------ | | | | | | | | 1070| 136k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (1094:26): [True: 106k, False: 136k] | | ------------------ ------------------ 1662| 243k| vmbreak; ------------------ | | 16| 243k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 243k|#define vmfetch() { \ | | | | 1134| 243k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 243k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 243k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 243k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 243k| i = *(pc++); \ | | | | 1139| 243k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 243k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1663| 243k| } 1664| 243k| vmcase(OP_TESTSET) { ------------------ | | 14| 174k|#define vmcase(l) L_##l: ------------------ 1665| 174k| StkId ra = RA(i); ------------------ | | 1059| 174k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 174k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 174k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 174k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 174k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1666| 174k| TValue *rb = vRB(i); ------------------ | | 1061| 174k|#define vRB(i) s2v(RB(i)) | | ------------------ | | | | 172| 174k|#define s2v(o) (&(o)->val) | | ------------------ ------------------ 1667| 174k| if (l_isfalse(rb) == GETARG_k(i)) ------------------ | | 247| 174k|#define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 243| 174k|#define ttisfalse(o) checktag((o), LUA_VFALSE) | | | | ------------------ | | | | | | 91| 349k|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 174k|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 174k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_isfalse(o) (ttisfalse(o) || ttisnil(o)) | | ------------------ | | | | 193| 174k|#define ttisnil(v) checktype((v), LUA_TNIL) | | | | ------------------ | | | | | | 92| 174k|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 174k|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 174k|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | | Branch (92:25): [True: 0, False: 174k] | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ if (l_isfalse(rb) == GETARG_k(i)) ------------------ | | 137| 174k|#define GETARG_k(i) check_exp(checkopm(i, iABC), getarg(i, POS_k, 1)) | | ------------------ | | | | 115| 174k|#define check_exp(c,e) (e) | | ------------------ ------------------ | Branch (1667:13): [True: 55.1k, False: 119k] ------------------ 1668| 55.1k| pc++; 1669| 119k| else { 1670| 119k| setobj2s(L, ra, rb); ------------------ | | 131| 119k|#define setobj2s(L,o1,o2) setobj(L,s2v(o1),o2) | | ------------------ | | | | 119| 119k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 119k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 119k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 119k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 119k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 119k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 119k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 119k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1671| 119k| donextjump(ci); ------------------ | | 1087| 119k|#define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); } | | ------------------ | | | | 1083| 119k|#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | ------------------ | | | | | | 151| 119k| check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ) | | | | | | ------------------ | | | | | | | | 115| 119k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); } | | | | ------------------ | | | | | | 1070| 119k|#define updatetrap(ci) (trap = ci->u.l.trap) | | | | ------------------ | | ------------------ ------------------ 1672| 119k| } 1673| 174k| vmbreak; ------------------ | | 16| 174k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 174k|#define vmfetch() { \ | | | | 1134| 174k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 174k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 174k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 174k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 174k| i = *(pc++); \ | | | | 1139| 174k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 174k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1674| 174k| } 1675| 174k| vmcase(OP_CALL) { ------------------ | | 14| 19.7k|#define vmcase(l) L_##l: ------------------ 1676| 19.7k| StkId ra = RA(i); ------------------ | | 1059| 19.7k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 19.7k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 19.7k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 19.7k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 19.7k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1677| 19.7k| CallInfo *newci; 1678| 19.7k| int b = GETARG_B(i); ------------------ | | 128| 19.7k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 19.7k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1679| 19.7k| int nresults = GETARG_C(i) - 1; ------------------ | | 132| 19.7k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 19.7k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1680| 19.7k| if (b != 0) /* fixed number of arguments? */ ------------------ | Branch (1680:13): [True: 18.4k, False: 1.30k] ------------------ 1681| 18.4k| L->top.p = ra + b; /* top signals number of arguments */ 1682| | /* else previous instruction set top */ 1683| 19.7k| savepc(L); /* in case of errors */ ------------------ | | 1100| 19.7k|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1684| 19.7k| if ((newci = luaD_precall(L, ra, nresults)) == NULL) ------------------ | Branch (1684:13): [True: 0, False: 19.7k] ------------------ 1685| 0| updatetrap(ci); /* C call; nothing else to be done */ ------------------ | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1686| 19.7k| else { /* Lua call: run function in this same C frame */ 1687| 19.7k| ci = newci; 1688| 19.7k| goto startfunc; 1689| 19.7k| } 1690| 19.7k| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1691| 0| } 1692| 16| vmcase(OP_TAILCALL) { ------------------ | | 14| 16|#define vmcase(l) L_##l: ------------------ 1693| 16| StkId ra = RA(i); ------------------ | | 1059| 16|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 16|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 16|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 16|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 16|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1694| 16| int b = GETARG_B(i); /* number of arguments + 1 (function) */ ------------------ | | 128| 16|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ 1695| 16| int n; /* number of results when calling a C function */ 1696| 16| int nparams1 = GETARG_C(i); ------------------ | | 132| 16|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ 1697| | /* delta is virtual 'func' - real 'func' (vararg functions) */ 1698| 16| int delta = (nparams1) ? ci->u.l.nextraargs + nparams1 : 0; ------------------ | Branch (1698:21): [True: 0, False: 16] ------------------ 1699| 16| if (b != 0) ------------------ | Branch (1699:13): [True: 16, False: 0] ------------------ 1700| 16| L->top.p = ra + b; 1701| 0| else /* previous instruction set top */ 1702| 0| b = cast_int(L->top.p - ra); ------------------ | | 141| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1703| 16| savepc(ci); /* several calls here can raise errors */ ------------------ | | 1100| 16|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1704| 16| if (TESTARG_k(i)) { ------------------ | | 136| 16|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:25): [True: 0, False: 16] | | | | ------------------ | | ------------------ ------------------ 1705| 0| luaF_closeupval(L, base); /* close upvalues from current call */ 1706| 0| lua_assert(L->tbclist.p < base); /* no pending tbc variables */ ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 1707| 0| lua_assert(base == ci->func.p + 1); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 1708| 0| } 1709| 16| if ((n = luaD_pretailcall(L, ci, ra, b, delta)) < 0) /* Lua function? */ ------------------ | Branch (1709:13): [True: 16, False: 0] ------------------ 1710| 16| goto startfunc; /* execute the callee */ 1711| 0| else { /* C function? */ 1712| 0| ci->func.p -= delta; /* restore 'func' (if vararg) */ 1713| 0| luaD_poscall(L, ci, n); /* finish caller */ 1714| 0| updatetrap(ci); /* 'luaD_poscall' can change hooks */ ------------------ | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1715| 0| goto ret; /* caller returns after the tail call */ 1716| 0| } 1717| 16| } 1718| 2| vmcase(OP_RETURN) { ------------------ | | 14| 2|#define vmcase(l) L_##l: ------------------ 1719| 2| StkId ra = RA(i); ------------------ | | 1059| 2|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 2|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 2|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 2|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 2|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1720| 2| int n = GETARG_B(i) - 1; /* number of results */ ------------------ | | 128| 2|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 2|#define check_exp(c,e) (e) | | ------------------ ------------------ 1721| 2| int nparams1 = GETARG_C(i); ------------------ | | 132| 2|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 2|#define check_exp(c,e) (e) | | ------------------ ------------------ 1722| 2| if (n < 0) /* not fixed? */ ------------------ | Branch (1722:13): [True: 0, False: 2] ------------------ 1723| 0| n = cast_int(L->top.p - ra); /* get what is available */ ------------------ | | 141| 0|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1724| 2| savepc(ci); ------------------ | | 1100| 2|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1725| 2| if (TESTARG_k(i)) { /* may there be open upvalues? */ ------------------ | | 136| 2|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 115| 2|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:25): [True: 0, False: 2] | | | | ------------------ | | ------------------ ------------------ 1726| 0| ci->u2.nres = n; /* save number of returns */ 1727| 0| if (L->top.p < ci->top.p) ------------------ | Branch (1727:15): [True: 0, False: 0] ------------------ 1728| 0| L->top.p = ci->top.p; 1729| 0| luaF_close(L, base, CLOSEKTOP, 1); ------------------ | | 47| 0|#define CLOSEKTOP (-1) ------------------ 1730| 0| updatetrap(ci); ------------------ | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1731| 0| updatestack(ci); ------------------ | | 1076| 0| { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | | | ------------------ | | | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | ------------------ | | | | | | | Branch (676:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | ------------------ | | { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1732| 0| } 1733| 2| if (nparams1) /* vararg function? */ ------------------ | Branch (1733:13): [True: 2, False: 0] ------------------ 1734| 2| ci->func.p -= ci->u.l.nextraargs + nparams1; 1735| 2| L->top.p = ra + n; /* set call for 'luaD_poscall' */ 1736| 2| luaD_poscall(L, ci, n); 1737| 2| updatetrap(ci); /* 'luaD_poscall' can change hooks */ ------------------ | | 1070| 2|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1738| 2| goto ret; 1739| 16| } 1740| 1| vmcase(OP_RETURN0) { ------------------ | | 14| 1|#define vmcase(l) L_##l: ------------------ 1741| 1| if (l_unlikely(L->hookmask)) { ------------------ | | 688| 1|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 1|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 1] | | | | ------------------ | | ------------------ ------------------ 1742| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1743| 0| L->top.p = ra; 1744| 0| savepc(ci); ------------------ | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1745| 0| luaD_poscall(L, ci, 0); /* no hurry... */ 1746| 0| trap = 1; 1747| 0| } 1748| 1| else { /* do the 'poscall' here */ 1749| 1| int nres; 1750| 1| L->ci = ci->previous; /* back to caller */ 1751| 1| L->top.p = base - 1; 1752| 8| for (nres = ci->nresults; l_unlikely(nres > 0); nres--) 1753| 8| setnilvalue(s2v(L->top.p++)); /* all results are nil */ ------------------ | | 200| 8|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 8|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1754| 1| } 1755| 1| goto ret; 1756| 16| } 1757| 18.4k| vmcase(OP_RETURN1) { ------------------ | | 14| 18.4k|#define vmcase(l) L_##l: ------------------ 1758| 18.4k| if (l_unlikely(L->hookmask)) { ------------------ | | 688| 18.4k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 18.4k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 18.4k] | | | | ------------------ | | ------------------ ------------------ 1759| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1760| 0| L->top.p = ra + 1; 1761| 0| savepc(ci); ------------------ | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) ------------------ 1762| 0| luaD_poscall(L, ci, 1); /* no hurry... */ 1763| 0| trap = 1; 1764| 0| } 1765| 18.4k| else { /* do the 'poscall' here */ 1766| 18.4k| int nres = ci->nresults; 1767| 18.4k| L->ci = ci->previous; /* back to caller */ 1768| 18.4k| if (nres == 0) ------------------ | Branch (1768:15): [True: 9.19k, False: 9.21k] ------------------ 1769| 9.19k| L->top.p = base - 1; /* asked for no results */ 1770| 9.21k| else { 1771| 9.21k| StkId ra = RA(i); ------------------ | | 1059| 9.21k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 9.21k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 9.21k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 9.21k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 9.21k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1772| 9.21k| setobjs2s(L, base - 1, ra); /* at least this result */ ------------------ | | 129| 9.21k|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 9.21k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 9.21k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 9.21k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 9.21k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 9.21k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 9.21k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 9.21k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 9.21k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1773| 9.21k| L->top.p = base; 1774| 9.21k| for (; l_unlikely(nres > 1); nres--) 1775| 9.21k| setnilvalue(s2v(L->top.p++)); /* complete missing results */ ------------------ | | 200| 80|#define setnilvalue(obj) settt_(obj, LUA_VNIL) | | ------------------ | | | | 114| 80|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1776| 9.21k| } 1777| 18.4k| } 1778| 18.4k| ret: /* return from a Lua function */ 1779| 18.4k| if (ci->callstatus & CIST_FRESH) ------------------ | | 212| 18.4k|#define CIST_FRESH (1<<2) /* call is on a fresh "luaV_execute" frame */ ------------------ | Branch (1779:13): [True: 1, False: 18.4k] ------------------ 1780| 1| return; /* end this frame */ 1781| 18.4k| else { 1782| 18.4k| ci = ci->previous; 1783| 18.4k| goto returning; /* continue running caller in this frame */ 1784| 18.4k| } 1785| 18.4k| } 1786| 9.73k| vmcase(OP_FORLOOP) { ------------------ | | 14| 9.73k|#define vmcase(l) L_##l: ------------------ 1787| 9.73k| StkId ra = RA(i); ------------------ | | 1059| 9.73k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 9.73k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 9.73k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 9.73k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 9.73k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1788| 9.73k| if (ttisinteger(s2v(ra + 2))) { /* integer loop? */ ------------------ | | 328| 9.73k|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 9.73k|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 9.73k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 9.73k, False: 0] | | | | ------------------ | | ------------------ ------------------ 1789| 9.73k| lua_Unsigned count = l_castS2U(ivalue(s2v(ra + 1))); ------------------ | | 152| 9.73k|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 1790| 9.73k| if (count > 0) { /* still more iterations? */ ------------------ | Branch (1790:15): [True: 9.73k, False: 2] ------------------ 1791| 9.73k| lua_Integer step = ivalue(s2v(ra + 2)); ------------------ | | 333| 9.73k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 9.73k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1792| 9.73k| lua_Integer idx = ivalue(s2v(ra)); /* internal index */ ------------------ | | 333| 9.73k|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 9.73k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1793| 9.73k| chgivalue(s2v(ra + 1), count - 1); /* update counter */ ------------------ | | 348| 9.73k| { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 114| 9.73k|#define lua_assert(c) ((void)0) | | ------------------ | | { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 72| 9.73k|#define val_(o) ((o)->value_) | | ------------------ ------------------ 1794| 9.73k| idx = intop(+, idx, step); /* add step to index */ ------------------ | | 73| 9.73k|#define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2)) | | ------------------ | | | | 161| 9.73k|#define l_castU2S(i) ((lua_Integer)(i)) | | ------------------ ------------------ 1795| 9.73k| chgivalue(s2v(ra), idx); /* update internal index */ ------------------ | | 348| 9.73k| { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 114| 9.73k|#define lua_assert(c) ((void)0) | | ------------------ | | { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); } | | ------------------ | | | | 72| 9.73k|#define val_(o) ((o)->value_) | | ------------------ ------------------ 1796| 9.73k| setivalue(s2v(ra + 3), idx); /* and control variable */ ------------------ | | 345| 9.73k| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 9.73k|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 9.73k|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 1797| 9.73k| pc -= GETARG_Bx(i); /* jump back */ ------------------ | | 140| 9.73k|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 115| 9.73k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1798| 9.73k| } 1799| 9.73k| } 1800| 0| else if (floatforloop(ra)) /* float loop */ ------------------ | Branch (1800:18): [True: 0, False: 0] ------------------ 1801| 0| pc -= GETARG_Bx(i); /* jump back */ ------------------ | | 140| 0|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1802| 9.73k| updatetrap(ci); /* allows a signal to break the loop */ ------------------ | | 1070| 9.73k|#define updatetrap(ci) (trap = ci->u.l.trap) ------------------ 1803| 9.73k| vmbreak; ------------------ | | 16| 9.73k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 9.73k|#define vmfetch() { \ | | | | 1134| 9.73k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 9.73k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 9.73k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 9.73k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 9.73k| i = *(pc++); \ | | | | 1139| 9.73k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 9.73k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1804| 9.73k| } 1805| 9.73k| vmcase(OP_FORPREP) { ------------------ | | 14| 12|#define vmcase(l) L_##l: ------------------ 1806| 12| StkId ra = RA(i); ------------------ | | 1059| 12|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 12|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 12|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 12|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 12|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1807| 12| savestate(L, ci); /* in case of errors */ ------------------ | | 1107| 12|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | ------------------ | | | | 1100| 12|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ ------------------ 1808| 12| if (forprep(L, ra)) ------------------ | Branch (1808:13): [True: 0, False: 12] ------------------ 1809| 0| pc += GETARG_Bx(i) + 1; /* skip the loop */ ------------------ | | 140| 0|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1810| 12| vmbreak; ------------------ | | 16| 12|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 12|#define vmfetch() { \ | | | | 1134| 12| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 12|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 12|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 12] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 12| i = *(pc++); \ | | | | 1139| 12|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 12|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1811| 12| } 1812| 12| vmcase(OP_TFORPREP) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1813| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1814| | /* create to-be-closed upvalue (if needed) */ 1815| 0| halfProtect(luaF_newtbcupval(L, ra + 3)); ------------------ | | 1123| 0|#define halfProtect(exp) (savestate(L,ci), (exp)) | | ------------------ | | | | 1107| 0|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ ------------------ 1816| 0| pc += GETARG_Bx(i); ------------------ | | 140| 0|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1817| 0| i = *(pc++); /* go to next instruction */ 1818| 0| lua_assert(GET_OPCODE(i) == OP_TFORCALL && ra == RA(i)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 1819| 0| goto l_tforcall; 1820| 12| } 1821| 0| vmcase(OP_TFORCALL) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1822| 0| l_tforcall: { 1823| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1824| | /* 'ra' has the iterator function, 'ra + 1' has the state, 1825| | 'ra + 2' has the control variable, and 'ra + 3' has the 1826| | to-be-closed variable. The call will use the stack after 1827| | these values (starting at 'ra + 4') 1828| | */ 1829| | /* push function, state, and control variable */ 1830| 0| memcpy(ra + 4, ra, 3 * sizeof(*ra)); 1831| 0| L->top.p = ra + 4 + 3; 1832| 0| ProtectNT(luaD_call(L, ra + 4, GETARG_C(i))); /* do the call */ ------------------ | | 1117| 0|#define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1100| 0|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ | | #define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 0|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1833| 0| updatestack(ci); /* stack may have changed */ ------------------ | | 1076| 0| { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | | | ------------------ | | | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | ------------------ | | | | | | | Branch (676:26): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | ------------------ | | { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } } | | ------------------ | | | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | | | ------------------ | | | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | | | ------------------ | | | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | | | ------------------ | | | | | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | | | ------------------ | | | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1834| 0| i = *(pc++); /* go to next instruction */ 1835| 0| lua_assert(GET_OPCODE(i) == OP_TFORLOOP && ra == RA(i)); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 1836| 0| goto l_tforloop; 1837| 0| }} 1838| 0| vmcase(OP_TFORLOOP) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1839| 0| l_tforloop: { 1840| 0| StkId ra = RA(i); ------------------ | | 1059| 0|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 0|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 0|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 0|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 0|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1841| 0| if (!ttisnil(s2v(ra + 4))) { /* continue loop? */ ------------------ | | 193| 0|#define ttisnil(v) checktype((v), LUA_TNIL) | | ------------------ | | | | 92| 0|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 0|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 0|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (1841:13): [True: 0, False: 0] ------------------ 1842| 0| setobjs2s(L, ra + 2, ra + 4); /* save control variable */ ------------------ | | 129| 0|#define setobjs2s(L,o1,o2) setobj(L,s2v(o1),s2v(o2)) | | ------------------ | | | | 119| 0| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 0| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 0| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 0| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 0|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 0| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 0|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1843| 0| pc -= GETARG_Bx(i); /* jump back */ ------------------ | | 140| 0|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 1844| 0| } 1845| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1846| 0| }} 1847| 119k| vmcase(OP_SETLIST) { ------------------ | | 14| 119k|#define vmcase(l) L_##l: ------------------ 1848| 119k| StkId ra = RA(i); ------------------ | | 1059| 119k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 119k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 119k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 119k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 119k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1849| 119k| int n = GETARG_B(i); ------------------ | | 128| 119k|#define GETARG_B(i) check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B)) | | ------------------ | | | | 115| 119k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1850| 119k| unsigned int last = GETARG_C(i); ------------------ | | 132| 119k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 119k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1851| 119k| Table *h = hvalue(s2v(ra)); ------------------ | | 684| 119k|#define hvalue(o) check_exp(ttistable(o), gco2t(val_(o).gc)) | | ------------------ | | | | 115| 119k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1852| 119k| if (n == 0) ------------------ | Branch (1852:13): [True: 1, False: 119k] ------------------ 1853| 1| n = cast_int(L->top.p - ra) - 1; /* get up to the top */ ------------------ | | 141| 1|#define cast_int(i) cast(int, (i)) | | ------------------ | | | | 136| 1|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 1854| 119k| else 1855| 119k| L->top.p = ci->top.p; /* correct top in case of emergency GC */ 1856| 119k| last += n; 1857| 119k| if (TESTARG_k(i)) { ------------------ | | 136| 119k|#define TESTARG_k(i) check_exp(checkopm(i, iABC), (cast_int(((i) & (1u << POS_k))))) | | ------------------ | | | | 115| 119k|#define check_exp(c,e) (e) | | | | ------------------ | | | | | Branch (115:25): [True: 0, False: 119k] | | | | ------------------ | | ------------------ ------------------ 1858| 0| last += GETARG_Ax(*pc) * (MAXARG_C + 1); ------------------ | | 143| 0|#define GETARG_Ax(i) check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax)) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ last += GETARG_Ax(*pc) * (MAXARG_C + 1); ------------------ | | 97| 0|#define MAXARG_C ((1< luaH_realasize(h)) /* needs more space? */ ------------------ | Branch (1861:13): [True: 1, False: 119k] ------------------ 1862| 1| luaH_resizearray(L, h, last); /* preallocate it at once */ 1863| 239k| for (; n > 0; n--) { ------------------ | Branch (1863:16): [True: 119k, False: 119k] ------------------ 1864| 119k| TValue *val = s2v(ra + n); ------------------ | | 172| 119k|#define s2v(o) (&(o)->val) ------------------ 1865| 119k| setobj2t(L, &h->array[last - 1], val); ------------------ | | 137| 119k|#define setobj2t setobj | | ------------------ | | | | 119| 119k| { TValue *io1=(obj1); const TValue *io2=(obj2); \ | | | | 120| 119k| io1->value_ = io2->value_; settt_(io1, io2->tt_); \ | | | | ------------------ | | | | | | 114| 119k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 121| 119k| checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 107| 119k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 119k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 119k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | | | checkliveness(L,io1); lua_assert(!isnonstrictnil(io1)); } | | | | ------------------ | | | | | | 114| 119k|#define lua_assert(c) ((void)0) | | | | ------------------ | | ------------------ ------------------ 1866| 119k| last--; 1867| 119k| luaC_barrierback(L, obj2gco(h), val); ------------------ | | 185| 119k|#define luaC_barrierback(L,p,v) ( \ | | 186| 119k| iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 300| 119k|#define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 77| 119k|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | #define iscollectable(o) (rawtt(o) & BIT_ISCOLLECTABLE) | | | | ------------------ | | | | | | 298| 119k|#define BIT_ISCOLLECTABLE (1 << 6) | | | | ------------------ | | | | | Branch (300:26): [True: 1, False: 119k] | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 182| 1|#define luaC_objbarrierback(L,p,o) ( \ | | | | 183| 1| (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 88| 1|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | | | ------------------ | | | | | | | | 67| 1|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | | | ------------------ | | | | | | | | | | 62| 2|#define testbits(x,m) ((x) & (m)) | | | | | | | | | | ------------------ | | | | | | | | | | | Branch (62:24): [True: 0, False: 1] | | | | | | | | | | ------------------ | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | | | ------------------ | | | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | (isblack(p) && iswhite(o)) ? luaC_barrierback_(L,p) : cast_void(0)) | | | | ------------------ | | | | | | 138| 1|#define cast_void(i) cast(void, (i)) | | | | | | ------------------ | | | | | | | | 136| 1|#define cast(t, exp) ((t)(exp)) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | iscollectable(v) ? luaC_objbarrierback(L, p, gcvalue(v)) : cast_void(0)) | | ------------------ | | | | 138| 119k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 119k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 1868| 119k| } 1869| 119k| vmbreak; ------------------ | | 16| 119k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 119k|#define vmfetch() { \ | | | | 1134| 119k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 119k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 119k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 119k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 119k| i = *(pc++); \ | | | | 1139| 119k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 119k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1870| 119k| } 1871| 119k| vmcase(OP_CLOSURE) { ------------------ | | 14| 9.23k|#define vmcase(l) L_##l: ------------------ 1872| 9.23k| StkId ra = RA(i); ------------------ | | 1059| 9.23k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 9.23k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 9.23k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 9.23k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 9.23k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1873| 9.23k| Proto *p = cl->p->p[GETARG_Bx(i)]; ------------------ | | 140| 9.23k|#define GETARG_Bx(i) check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx)) | | ------------------ | | | | 115| 9.23k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1874| 9.23k| halfProtect(pushclosure(L, p, cl->upvals, base, ra)); ------------------ | | 1123| 9.23k|#define halfProtect(exp) (savestate(L,ci), (exp)) | | ------------------ | | | | 1107| 9.23k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 9.23k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ ------------------ 1875| 9.23k| checkGC(L, ra + 1); ------------------ | | 1127| 9.23k| { luaC_condGC(L, (savepc(L), L->top.p = (c)), \ | | ------------------ | | | | 168| 9.23k| { if (G(L)->GCdebt > 0) { pre; luaC_step(L); pos;}; \ | | | | ------------------ | | | | | | 335| 9.23k|#define G(L) (L->l_G) | | | | ------------------ | | | | | Branch (168:8): [True: 0, False: 9.23k] | | | | ------------------ | | | | 169| 9.23k| condchangemem(L,pre,pos); } | | | | ------------------ | | | | | | 374| 9.23k|#define condchangemem(L,pre,pos) ((void)0) | | | | ------------------ | | ------------------ | | 1128| 9.23k| updatetrap(ci)); \ | | 1129| 9.23k| luai_threadyield(L); } | | ------------------ | | | | 273| 9.23k|#define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 265| 9.23k|#define lua_unlock(L) ((void) 0) | | | | ------------------ | | | | #define luai_threadyield(L) {lua_unlock(L); lua_lock(L);} | | | | ------------------ | | | | | | 264| 9.23k|#define lua_lock(L) ((void) 0) | | | | ------------------ | | ------------------ ------------------ 1876| 9.23k| vmbreak; ------------------ | | 16| 9.23k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 9.23k|#define vmfetch() { \ | | | | 1134| 9.23k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 9.23k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 9.23k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 9.23k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 9.23k| i = *(pc++); \ | | | | 1139| 9.23k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 9.23k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1877| 9.23k| } 1878| 203k| vmcase(OP_VARARG) { ------------------ | | 14| 203k|#define vmcase(l) L_##l: ------------------ 1879| 203k| StkId ra = RA(i); ------------------ | | 1059| 203k|#define RA(i) (base+GETARG_A(i)) | | ------------------ | | | | 125| 203k|#define GETARG_A(i) getarg(i, POS_A, SIZE_A) | | | | ------------------ | | | | | | 121| 203k|#define getarg(i,pos,size) (cast_int(((i)>>(pos)) & MASK1(size,0))) | | | | | | ------------------ | | | | | | | | 141| 203k|#define cast_int(i) cast(int, (i)) | | | | | | | | ------------------ | | | | | | | | | | 136| 203k|#define cast(t, exp) ((t)(exp)) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 1880| 203k| int n = GETARG_C(i) - 1; /* required results */ ------------------ | | 132| 203k|#define GETARG_C(i) check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C)) | | ------------------ | | | | 115| 203k|#define check_exp(c,e) (e) | | ------------------ ------------------ 1881| 203k| Protect(luaT_getvarargs(L, ci, ra, n)); ------------------ | | 1114| 203k|#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1107| 203k|#define savestate(L,ci) (savepc(L), L->top.p = ci->top.p) | | | | ------------------ | | | | | | 1100| 203k|#define savepc(L) (ci->u.l.savedpc = pc) | | | | ------------------ | | ------------------ | | #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 203k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1882| 203k| vmbreak; ------------------ | | 16| 203k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 203k|#define vmfetch() { \ | | | | 1134| 203k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 203k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 203k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 6, False: 203k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 6| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 6| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 6|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 6| } \ | | | | 1138| 203k| i = *(pc++); \ | | | | 1139| 203k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 203k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1883| 203k| } 1884| 203k| vmcase(OP_VARARGPREP) { ------------------ | | 14| 1.34k|#define vmcase(l) L_##l: ------------------ 1885| 1.34k| ProtectNT(luaT_adjustvarargs(L, GETARG_A(i), ci, cl->p)); ------------------ | | 1117| 1.34k|#define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1100| 1.34k|#define savepc(L) (ci->u.l.savedpc = pc) | | ------------------ | | #define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci)) | | ------------------ | | | | 1070| 1.34k|#define updatetrap(ci) (trap = ci->u.l.trap) | | ------------------ ------------------ 1886| 1.34k| if (l_unlikely(trap)) { /* previous "Protect" updated trap */ ------------------ | | 688| 1.34k|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 1.34k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 2, False: 1.34k] | | | | ------------------ | | ------------------ ------------------ 1887| 2| luaD_hookcall(L, ci); 1888| 2| L->oldpc = 1; /* next opcode will be seen as a "new" line */ 1889| 2| } 1890| 1.34k| updatebase(ci); /* function has new base after adjustment */ ------------------ | | 1072| 1.34k|#define updatebase(ci) (base = ci->func.p + 1) ------------------ 1891| 1.34k| vmbreak; ------------------ | | 16| 1.34k|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 1.34k|#define vmfetch() { \ | | | | 1134| 1.34k| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 1.34k|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 1.34k|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 2, False: 1.34k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 2| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 2| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 2|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 2| } \ | | | | 1138| 1.34k| i = *(pc++); \ | | | | 1139| 1.34k|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 1.34k|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1892| 1.34k| } 1893| 1.34k| vmcase(OP_EXTRAARG) { ------------------ | | 14| 0|#define vmcase(l) L_##l: ------------------ 1894| 0| lua_assert(0); ------------------ | | 114| 0|#define lua_assert(c) ((void)0) ------------------ 1895| 0| vmbreak; ------------------ | | 16| 0|#define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 1133| 0|#define vmfetch() { \ | | | | 1134| 0| if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \ | | | | ------------------ | | | | | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | | | | | ------------------ | | | | | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | | | | | ------------------ | | | | | | | | | Branch (676:26): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | | | 1135| 0| trap = luaG_traceexec(L, pc); /* handle hooks */ \ | | | | 1136| 0| updatebase(ci); /* correct stack */ \ | | | | ------------------ | | | | | | 1072| 0|#define updatebase(ci) (base = ci->func.p + 1) | | | | ------------------ | | | | 1137| 0| } \ | | | | 1138| 0| i = *(pc++); \ | | | | 1139| 0|} | | ------------------ | | #define vmbreak vmfetch(); vmdispatch(GET_OPCODE(i)); | | ------------------ | | | | 12| 0|#define vmdispatch(x) goto *disptab[x]; | | ------------------ ------------------ 1896| 0| } 1897| 0| } 1898| 0| } 1899| 38.1k|} lvm.c:l_strton: 90| 14|static int l_strton (const TValue *obj, TValue *result) { 91| 14| lua_assert(obj != result); ------------------ | | 114| 14|#define lua_assert(c) ((void)0) ------------------ 92| 14| if (!cvt2num(obj)) /* is object not a string? */ ------------------ | | 24| 14|#define cvt2num(o) ttisstring(o) | | ------------------ | | | | 363| 14|#define ttisstring(o) checktype((o), LUA_TSTRING) | | | | ------------------ | | | | | | 92| 14|#define checktype(o,t) (ttype(o) == (t)) | | | | | | ------------------ | | | | | | | | 87| 14|#define ttype(o) (novariant(rawtt(o))) | | | | | | | | ------------------ | | | | | | | | | | 80| 14|#define novariant(t) ((t) & 0x0F) | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ | Branch (92:7): [True: 7, False: 7] ------------------ 93| 7| return 0; 94| 7| else 95| 7| return (luaO_str2num(svalue(obj), result) == vslen(obj) + 1); ------------------ | | 407| 7|#define svalue(o) getstr(tsvalue(o)) | | ------------------ | | | | 403| 7|#define getstr(ts) ((ts)->contents) | | ------------------ ------------------ return (luaO_str2num(svalue(obj), result) == vslen(obj) + 1); ------------------ | | 413| 7|#define vslen(o) tsslen(tsvalue(o)) | | ------------------ | | | | 410| 7|#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen) | | | | ------------------ | | | | | | 360| 7|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | | | ------------------ | | | | | | | | 42| 7|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (410:20): [True: 0, False: 7] | | | | ------------------ | | ------------------ ------------------ 96| 14|} lvm.c:lessthanothers: 520| 17|static int lessthanothers (lua_State *L, const TValue *l, const TValue *r) { 521| 17| lua_assert(!ttisnumber(l) || !ttisnumber(r)); ------------------ | | 114| 17|#define lua_assert(c) ((void)0) ------------------ 522| 17| if (ttisstring(l) && ttisstring(r)) /* both are strings? */ ------------------ | | 363| 17|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 34|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 17|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 17|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 16, False: 1] | | | | ------------------ | | ------------------ ------------------ if (ttisstring(l) && ttisstring(r)) /* both are strings? */ ------------------ | | 363| 16|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 16|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 16|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 16|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 16, False: 0] | | | | ------------------ | | ------------------ ------------------ 523| 16| return l_strcmp(tsvalue(l), tsvalue(r)) < 0; ------------------ | | 369| 16|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ return l_strcmp(tsvalue(l), tsvalue(r)) < 0; ------------------ | | 369| 16|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 16|#define check_exp(c,e) (e) | | ------------------ ------------------ 524| 1| else 525| 1| return luaT_callorderTM(L, l, r, TM_LT); 526| 17|} lvm.c:l_strcmp: 375| 20|static int l_strcmp (const TString *ls, const TString *rs) { 376| 20| const char *l = getstr(ls); ------------------ | | 403| 20|#define getstr(ts) ((ts)->contents) ------------------ 377| 20| size_t ll = tsslen(ls); ------------------ | | 410| 20|#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | | 360| 20|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | ------------------ | | | | | | 42| 20|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (410:20): [True: 20, False: 0] | | ------------------ ------------------ 378| 20| const char *r = getstr(rs); ------------------ | | 403| 20|#define getstr(ts) ((ts)->contents) ------------------ 379| 20| size_t lr = tsslen(rs); ------------------ | | 410| 20|#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen) | | ------------------ | | | | 360| 20|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | ------------------ | | | | | | 42| 20|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | ------------------ | | ------------------ | | | Branch (410:20): [True: 16, False: 4] | | ------------------ ------------------ 380| 24| for (;;) { /* for each segment */ 381| 24| int temp = strcoll(l, r); 382| 24| if (temp != 0) /* not equal? */ ------------------ | Branch (382:9): [True: 20, False: 4] ------------------ 383| 20| return temp; /* done */ 384| 4| else { /* strings are equal up to a '\0' */ 385| 4| size_t len = strlen(l); /* index of first '\0' in both strings */ 386| 4| if (len == lr) /* 'rs' is finished? */ ------------------ | Branch (386:11): [True: 0, False: 4] ------------------ 387| 0| return (len == ll) ? 0 : 1; /* check 'ls' */ ------------------ | Branch (387:16): [True: 0, False: 0] ------------------ 388| 4| else if (len == ll) /* 'ls' is finished? */ ------------------ | Branch (388:16): [True: 0, False: 4] ------------------ 389| 0| return -1; /* 'ls' is less than 'rs' ('rs' is not finished) */ 390| | /* both strings longer than 'len'; go on comparing after the '\0' */ 391| 4| len++; 392| 4| l += len; ll -= len; r += len; lr -= len; 393| 4| } 394| 24| } 395| 20|} lvm.c:LEnum: 498| 26|l_sinline int LEnum (const TValue *l, const TValue *r) { 499| 26| lua_assert(ttisnumber(l) && ttisnumber(r)); ------------------ | | 114| 26|#define lua_assert(c) ((void)0) ------------------ 500| 26| if (ttisinteger(l)) { ------------------ | | 328| 26|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 26|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 26|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 26, False: 0] | | | | ------------------ | | ------------------ ------------------ 501| 26| lua_Integer li = ivalue(l); ------------------ | | 333| 26|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 26|#define check_exp(c,e) (e) | | ------------------ ------------------ 502| 26| if (ttisinteger(r)) ------------------ | | 328| 26|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 26|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 26|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 26] | | | | ------------------ | | ------------------ ------------------ 503| 0| return li <= ivalue(r); /* both are integers */ ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 504| 26| else /* 'l' is int and 'r' is float */ 505| 26| return LEintfloat(li, fltvalue(r)); /* l <= r ? */ ------------------ | | 332| 26|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 26|#define check_exp(c,e) (e) | | ------------------ ------------------ 506| 26| } 507| 0| else { 508| 0| lua_Number lf = fltvalue(l); /* 'l' must be float */ ------------------ | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 509| 0| if (ttisfloat(r)) ------------------ | | 327| 0|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | ------------------ | | | | 91| 0|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 0|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 510| 0| return luai_numle(lf, fltvalue(r)); /* both are float */ ------------------ | | 352| 0|#define luai_numle(a,b) ((a)<=(b)) ------------------ 511| 0| else /* 'l' is float and 'r' is int */ 512| 0| return LEfloatint(lf, ivalue(r)); ------------------ | | 333| 0|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 0|#define check_exp(c,e) (e) | | ------------------ ------------------ 513| 0| } 514| 26|} lvm.c:LEintfloat: 426| 26|l_sinline int LEintfloat (lua_Integer i, lua_Number f) { 427| 26| if (l_intfitsf(i)) ------------------ | | 74| 26|#define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 26|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 26|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 466| 26|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 152| 26|#define l_castS2U(i) ((lua_Unsigned)(i)) | | ------------------ | | #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF)) | | ------------------ | | | | 71| 26|#define MAXINTFITSF ((lua_Unsigned)1 << NBM) | | | | ------------------ | | | | | | 58| 26|#define NBM (l_floatatt(MANT_DIG)) | | | | | | ------------------ | | | | | | | | 466| 26|#define l_floatatt(n) (DBL_##n) | | | | | | ------------------ | | | | ------------------ | | ------------------ | | | Branch (74:23): [True: 18, False: 8] | | ------------------ ------------------ 428| 18| return luai_numle(cast_num(i), f); /* compare them as floats */ ------------------ | | 352| 18|#define luai_numle(a,b) ((a)<=(b)) ------------------ 429| 8| else { /* i <= f <=> i <= floor(f) */ 430| 8| lua_Integer fi; 431| 8| if (luaV_flttointeger(f, &fi, F2Ifloor)) /* fi = floor(f) */ ------------------ | Branch (431:9): [True: 0, False: 8] ------------------ 432| 0| return i <= fi; /* compare them as integers */ 433| 8| else /* 'f' is either greater or less than all integers */ 434| 8| return f > 0; /* greater? */ 435| 8| } 436| 26|} lvm.c:lessequalothers: 542| 4|static int lessequalothers (lua_State *L, const TValue *l, const TValue *r) { 543| 4| lua_assert(!ttisnumber(l) || !ttisnumber(r)); ------------------ | | 114| 4|#define lua_assert(c) ((void)0) ------------------ 544| 4| if (ttisstring(l) && ttisstring(r)) /* both are strings? */ ------------------ | | 363| 4|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 8|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 4|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 4|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 4, False: 0] | | | | ------------------ | | ------------------ ------------------ if (ttisstring(l) && ttisstring(r)) /* both are strings? */ ------------------ | | 363| 4|#define ttisstring(o) checktype((o), LUA_TSTRING) | | ------------------ | | | | 92| 4|#define checktype(o,t) (ttype(o) == (t)) | | | | ------------------ | | | | | | 87| 4|#define ttype(o) (novariant(rawtt(o))) | | | | | | ------------------ | | | | | | | | 80| 4|#define novariant(t) ((t) & 0x0F) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (92:25): [True: 4, False: 0] | | | | ------------------ | | ------------------ ------------------ 545| 4| return l_strcmp(tsvalue(l), tsvalue(r)) <= 0; ------------------ | | 369| 4|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 4|#define check_exp(c,e) (e) | | ------------------ ------------------ return l_strcmp(tsvalue(l), tsvalue(r)) <= 0; ------------------ | | 369| 4|#define tsvalue(o) check_exp(ttisstring(o), gco2ts(val_(o).gc)) | | ------------------ | | | | 115| 4|#define check_exp(c,e) (e) | | ------------------ ------------------ 546| 0| else 547| 0| return luaT_callorderTM(L, l, r, TM_LE); 548| 4|} lvm.c:copy2buff: 624| 83.4k|static void copy2buff (StkId top, int n, char *buff) { 625| 83.4k| size_t tl = 0; /* size already copied */ 626| 166k| do { 627| 166k| size_t l = vslen(s2v(top - n)); /* length of string being copied */ ------------------ | | 413| 166k|#define vslen(o) tsslen(tsvalue(o)) | | ------------------ | | | | 410| 166k|#define tsslen(s) ((s)->tt == LUA_VSHRSTR ? (s)->shrlen : (s)->u.lnglen) | | | | ------------------ | | | | | | 360| 166k|#define LUA_VSHRSTR makevariant(LUA_TSTRING, 0) /* short strings */ | | | | | | ------------------ | | | | | | | | 42| 166k|#define makevariant(t,v) ((t) | ((v) << 4)) | | | | | | ------------------ | | | | ------------------ | | | | | Branch (410:20): [True: 166k, False: 659] | | | | ------------------ | | ------------------ ------------------ 628| 166k| memcpy(buff + tl, svalue(s2v(top - n)), l * sizeof(char)); ------------------ | | 407| 166k|#define svalue(o) getstr(tsvalue(o)) | | ------------------ | | | | 403| 166k|#define getstr(ts) ((ts)->contents) | | ------------------ ------------------ 629| 166k| tl += l; 630| 166k| } while (--n > 0); ------------------ | Branch (630:12): [True: 83.4k, False: 83.4k] ------------------ 631| 83.4k|} lvm.c:forprep: 206| 12|static int forprep (lua_State *L, StkId ra) { 207| 12| TValue *pinit = s2v(ra); ------------------ | | 172| 12|#define s2v(o) (&(o)->val) ------------------ 208| 12| TValue *plimit = s2v(ra + 1); ------------------ | | 172| 12|#define s2v(o) (&(o)->val) ------------------ 209| 12| TValue *pstep = s2v(ra + 2); ------------------ | | 172| 12|#define s2v(o) (&(o)->val) ------------------ 210| 12| if (ttisinteger(pinit) && ttisinteger(pstep)) { /* integer loop? */ ------------------ | | 328| 12|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 24|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 12|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 9, False: 3] | | | | ------------------ | | ------------------ ------------------ if (ttisinteger(pinit) && ttisinteger(pstep)) { /* integer loop? */ ------------------ | | 328| 9|#define ttisinteger(o) checktag((o), LUA_VNUMINT) | | ------------------ | | | | 91| 9|#define checktag(o,t) (rawtt(o) == (t)) | | | | ------------------ | | | | | | 77| 9|#define rawtt(o) ((o)->tt_) | | | | ------------------ | | | | | Branch (91:24): [True: 9, False: 0] | | | | ------------------ | | ------------------ ------------------ 211| 9| lua_Integer init = ivalue(pinit); ------------------ | | 333| 9|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 9|#define check_exp(c,e) (e) | | ------------------ ------------------ 212| 9| lua_Integer step = ivalue(pstep); ------------------ | | 333| 9|#define ivalue(o) check_exp(ttisinteger(o), val_(o).i) | | ------------------ | | | | 115| 9|#define check_exp(c,e) (e) | | ------------------ ------------------ 213| 9| lua_Integer limit; 214| 9| if (step == 0) ------------------ | Branch (214:9): [True: 0, False: 9] ------------------ 215| 0| luaG_runerror(L, "'for' step is zero"); 216| 9| setivalue(s2v(ra + 3), init); /* control variable */ ------------------ | | 345| 9| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 9|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 9|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 217| 9| if (forlimit(L, init, plimit, &limit, step)) ------------------ | Branch (217:9): [True: 0, False: 9] ------------------ 218| 0| return 1; /* skip the loop */ 219| 9| else { /* prepare loop counter */ 220| 9| lua_Unsigned count; 221| 9| if (step > 0) { /* ascending loop? */ ------------------ | Branch (221:11): [True: 7, False: 2] ------------------ 222| 7| count = l_castS2U(limit) - l_castS2U(init); ------------------ | | 152| 7|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ count = l_castS2U(limit) - l_castS2U(init); ------------------ | | 152| 7|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 223| 7| if (step != 1) /* avoid division in the too common case */ ------------------ | Branch (223:13): [True: 0, False: 7] ------------------ 224| 0| count /= l_castS2U(step); ------------------ | | 152| 0|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 225| 7| } 226| 2| else { /* step < 0; descending loop */ 227| 2| count = l_castS2U(init) - l_castS2U(limit); ------------------ | | 152| 2|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ count = l_castS2U(init) - l_castS2U(limit); ------------------ | | 152| 2|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 228| | /* 'step+1' avoids negating 'mininteger' */ 229| 2| count /= l_castS2U(-(step + 1)) + 1u; ------------------ | | 152| 2|#define l_castS2U(i) ((lua_Unsigned)(i)) ------------------ 230| 2| } 231| | /* store the counter in place of the limit (which won't be 232| | needed anymore) */ 233| 9| setivalue(plimit, l_castU2S(count)); ------------------ | | 345| 9| { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 72| 9|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_VNUMINT); } | | ------------------ | | | | 114| 9|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 234| 9| } 235| 9| } 236| 3| else { /* try making all values floats */ 237| 3| lua_Number init; lua_Number limit; lua_Number step; 238| 3| if (l_unlikely(!tonumber(plimit, &limit))) ------------------ | | 688| 3|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 6|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 3, False: 0] | | | | | Branch (676:46): [True: 0, False: 3] | | | | ------------------ | | ------------------ ------------------ 239| 3| luaG_forerror(L, plimit, "limit"); 240| 0| if (l_unlikely(!tonumber(pstep, &step))) ------------------ | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 0] | | | | | Branch (676:46): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 241| 0| luaG_forerror(L, pstep, "step"); 242| 0| if (l_unlikely(!tonumber(pinit, &init))) ------------------ | | 688| 0|#define l_unlikely(x) luai_unlikely(x) | | ------------------ | | | | 676| 0|#define luai_unlikely(x) (__builtin_expect(((x) != 0), 0)) | | | | ------------------ | | | | | Branch (676:26): [True: 0, False: 0] | | | | | Branch (676:46): [True: 0, False: 0] | | | | ------------------ | | ------------------ ------------------ 243| 0| luaG_forerror(L, pinit, "initial value"); 244| 0| if (step == 0) ------------------ | Branch (244:9): [True: 0, False: 0] ------------------ 245| 0| luaG_runerror(L, "'for' step is zero"); 246| 0| if (luai_numlt(0, step) ? luai_numlt(limit, init) ------------------ | | 351| 0|#define luai_numlt(a,b) ((a)<(b)) | | ------------------ | | | Branch (351:33): [True: 0, False: 0] | | ------------------ ------------------ if (luai_numlt(0, step) ? luai_numlt(limit, init) ------------------ | | 351| 0|#define luai_numlt(a,b) ((a)<(b)) ------------------ | Branch (246:9): [True: 0, False: 0] ------------------ 247| 0| : luai_numlt(init, limit)) ------------------ | | 351| 0|#define luai_numlt(a,b) ((a)<(b)) ------------------ 248| 0| return 1; /* skip the loop */ 249| 0| else { 250| | /* make sure internal values are all floats */ 251| 0| setfltvalue(plimit, limit); ------------------ | | 339| 0| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 0|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 252| 0| setfltvalue(pstep, step); ------------------ | | 339| 0| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 0|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 253| 0| setfltvalue(s2v(ra), init); /* internal index */ ------------------ | | 339| 0| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 0|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 254| 0| setfltvalue(s2v(ra + 3), init); /* control variable */ ------------------ | | 339| 0| { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 72| 0|#define val_(o) ((o)->value_) | | ------------------ | | { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_VNUMFLT); } | | ------------------ | | | | 114| 0|#define settt_(o,t) ((o)->tt_=(t)) | | ------------------ ------------------ 255| 0| } 256| 0| } 257| 9| return 0; 258| 12|} lvm.c:forlimit: 177| 9| lua_Integer *p, lua_Integer step) { 178| 9| if (!luaV_tointeger(lim, p, (step < 0 ? F2Iceil : F2Ifloor))) { ------------------ | Branch (178:7): [True: 2, False: 7] | Branch (178:32): [True: 0, False: 9] ------------------ 179| | /* not coercible to in integer */ 180| 2| lua_Number flim; /* try to convert to float */ 181| 2| if (!tonumber(lim, &flim)) /* cannot convert to float? */ ------------------ | | 52| 2| (ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n)) | | ------------------ | | | | 327| 2|#define ttisfloat(o) checktag((o), LUA_VNUMFLT) | | | | ------------------ | | | | | | 91| 2|#define checktag(o,t) (rawtt(o) == (t)) | | | | | | ------------------ | | | | | | | | 77| 2|#define rawtt(o) ((o)->tt_) | | | | | | ------------------ | | | | | | | Branch (91:24): [True: 0, False: 2] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n)) | | ------------------ | | | | 332| 0|#define fltvalue(o) check_exp(ttisfloat(o), val_(o).n) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ ------------------ | Branch (181:9): [True: 2, False: 0] ------------------ 182| 2| luaG_forerror(L, lim, "limit"); 183| | /* else 'flim' is a float out of integer bounds */ 184| 0| if (luai_numlt(0, flim)) { /* if it is positive, it is too large */ ------------------ | | 351| 0|#define luai_numlt(a,b) ((a)<(b)) | | ------------------ | | | Branch (351:33): [True: 0, False: 0] | | ------------------ ------------------ 185| 0| if (step < 0) return 1; /* initial value must be less than it */ ------------------ | Branch (185:11): [True: 0, False: 0] ------------------ 186| 0| *p = LUA_MAXINTEGER; /* truncate */ ------------------ | | 545| 0|#define LUA_MAXINTEGER LLONG_MAX ------------------ 187| 0| } 188| 0| else { /* it is less than min integer */ 189| 0| if (step > 0) return 1; /* initial value must be greater than it */ ------------------ | Branch (189:11): [True: 0, False: 0] ------------------ 190| 0| *p = LUA_MININTEGER; /* truncate */ ------------------ | | 546| 0|#define LUA_MININTEGER LLONG_MIN ------------------ 191| 0| } 192| 0| } 193| 7| return (step > 0 ? init > *p : init < *p); /* not to run? */ ------------------ | Branch (193:11): [True: 7, False: 0] ------------------ 194| 9|} lvm.c:pushclosure: 789| 9.23k| StkId ra) { 790| 9.23k| int nup = p->sizeupvalues; 791| 9.23k| Upvaldesc *uv = p->upvalues; 792| 9.23k| int i; 793| 9.23k| LClosure *ncl = luaF_newLclosure(L, nup); 794| 9.23k| ncl->p = p; 795| 9.23k| setclLvalue2s(L, ra, ncl); /* anchor new closure in stack */ ------------------ | | 615| 9.23k|#define setclLvalue2s(L,o,cl) setclLvalue(L,s2v(o),cl) | | ------------------ | | | | 611| 9.23k| { TValue *io = (obj); LClosure *x_ = (x); \ | | | | 612| 9.23k| val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 72| 9.23k|#define val_(o) ((o)->value_) | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 390| 9.23k|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | | | ------------------ | | | | | | | | 115| 9.23k|#define check_exp(c,e) (e) | | | | | | ------------------ | | | | ------------------ | | | | val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_VLCL)); \ | | | | ------------------ | | | | | | 114| 9.23k|#define settt_(o,t) ((o)->tt_=(t)) | | | | ------------------ | | | | 613| 9.23k| checkliveness(L,io); } | | | | ------------------ | | | | | | 107| 9.23k| ((void)L, lua_longassert(!iscollectable(obj) || \ | | | | | | ------------------ | | | | | | | | 116| 9.23k|#define lua_longassert(c) ((void)0) | | | | | | ------------------ | | | | | | 108| 9.23k| (righttt(obj) && (L == NULL || !isdead(G(L),gcvalue(obj)))))) | | | | ------------------ | | ------------------ ------------------ 796| 27.7k| for (i = 0; i < nup; i++) { /* fill in its upvalues */ ------------------ | Branch (796:15): [True: 18.4k, False: 9.23k] ------------------ 797| 18.4k| if (uv[i].instack) /* upvalue refers to local variable? */ ------------------ | Branch (797:9): [True: 9.22k, False: 9.26k] ------------------ 798| 9.22k| ncl->upvals[i] = luaF_findupval(L, base + uv[i].idx); 799| 9.26k| else /* get upvalue from enclosing function */ 800| 9.26k| ncl->upvals[i] = encup[uv[i].idx]; 801| 18.4k| luaC_objbarrier(L, ncl, ncl->upvals[i]); ------------------ | | 175| 18.4k|#define luaC_objbarrier(L,p,o) ( \ | | 176| 18.4k| (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 88| 18.4k|#define isblack(x) testbit((x)->marked, BLACKBIT) | | | | ------------------ | | | | | | 67| 18.4k|#define testbit(x,b) testbits(x, bitmask(b)) | | | | | | ------------------ | | | | | | | | 62| 36.9k|#define testbits(x,m) ((x) & (m)) | | | | | | | | ------------------ | | | | | | | | | Branch (62:24): [True: 0, False: 18.4k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | ------------------ | | ------------------ | | (isblack(p) && iswhite(o)) ? \ | | ------------------ | | | | 87| 0|#define iswhite(x) testbits((x)->marked, WHITEBITS) | | | | ------------------ | | | | | | 62| 0|#define testbits(x,m) ((x) & (m)) | | | | | | ------------------ | | | | | | | Branch (62:24): [True: 0, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 177| 18.4k| luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 390| 0|#define obj2gco(v) check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc)) | | | | ------------------ | | | | | | 115| 0|#define check_exp(c,e) (e) | | | | ------------------ | | ------------------ | | luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0)) | | ------------------ | | | | 138| 18.4k|#define cast_void(i) cast(void, (i)) | | | | ------------------ | | | | | | 136| 18.4k|#define cast(t, exp) ((t)(exp)) | | | | ------------------ | | ------------------ ------------------ 802| 18.4k| } 803| 9.23k|} luaZ_fill: 23| 351|int luaZ_fill (ZIO *z) { 24| 351| size_t size; 25| 351| lua_State *L = z->L; 26| 351| const char *buff; 27| 351| lua_unlock(L); ------------------ | | 265| 351|#define lua_unlock(L) ((void) 0) ------------------ 28| 351| buff = z->reader(L, z->data, &size); 29| 351| lua_lock(L); ------------------ | | 264| 351|#define lua_lock(L) ((void) 0) ------------------ 30| 351| if (buff == NULL || size == 0) ------------------ | Branch (30:7): [True: 93, False: 258] | Branch (30:23): [True: 0, False: 258] ------------------ 31| 93| return EOZ; ------------------ | | 16| 93|#define EOZ (-1) /* end of stream */ ------------------ 32| 258| z->n = size - 1; /* discount char being returned */ 33| 258| z->p = buff; 34| 258| return cast_uchar(*(z->p++)); ------------------ | | 144| 258|#define cast_uchar(i) cast(unsigned char, (i)) | | ------------------ | | | | 136| 258|#define cast(t, exp) ((t)(exp)) | | ------------------ ------------------ 35| 351|} luaZ_init: 38| 258|void luaZ_init (lua_State *L, ZIO *z, lua_Reader reader, void *data) { 39| 258| z->L = L; 40| 258| z->reader = reader; 41| 258| z->data = data; 42| 258| z->n = 0; 43| 258| z->p = NULL; 44| 258|}